1 HandlerThread介绍
HandlerThread的本质其实就是Thread封装了Looper。默认情况下,开启一个新的线程时,不会有Looper循环。HandlerThread带个我们的功能是:当开启一个新的线程时,默认帮我们建立好消息循环。方便我们的使用。
2 HandlerThread使用例子
public class MyActivity extends Activity {
private static final String TAG = "Test-Handler-Thread";
private static final int MESSAGE_FROM_MAIN_THREAD = 1;
private static final int MESSAGE_FROM_WORK_THREAD = 2;
private HandlerThread mHandlerThread;
private Handler mHandler;
/**
* Called when the activity is first created.
*/
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
mHandlerThread = new HandlerThread("Handler-Thread");
mHandlerThread.start();
mHandler = new Handler(mHandlerThread.getLooper()) {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case MESSAGE_FROM_MAIN_THREAD:
Log.d(TAG, "msg from main thread, handleMessage in thread:" + Thread.currentThread().getName());
break;
case MESSAGE_FROM_WORK_THREAD:
Log.d(TAG, "msg from work thread, handleMessage in thread:" + Thread.currentThread().getName());
break;
}
}
};
Message msg = Message.obtain();
msg.what = MESSAGE_FROM_MAIN_THREAD;
mHandler.sendMessage(msg);
new Thread(new Runnable() {
@Override
public void run() {
Message msg = Message.obtain();
msg.what = MESSAGE_FROM_WORK_THREAD;
mHandler.sendMessage(msg);
}
}).start();
}
@Override
protected void onDestroy() {
super.onDestroy();
mHandlerThread.quit();
}
}
以上代码我们构建好HandlerThread以后,调用start()启动这个线程,然后分别在主线程/工作子线程发送消息,交给handler处理。
打印结果如下:
Test-Handler-Thread﹕ msg from main thread, handleMessage in thread:Handler-Thread
Test-Handler-Thread﹕ msg from work thread, handleMessage in thread:Handler-Thread
由此可见,不管是从那个线程发送的消息,handler都会统一在HandlerThread线程中执行。
注意: 在使用HandlerThread时,使用完毕以后,一定要注意调用mHandlerThread.quit(),否则HandlerThread的消息循环一直不会退出,这样会导致消息循环一直存在,这样HandlerThread就不会退出,这样,引用HandlerThread的activity也不会销毁。这样会导致内存泄漏。
3 HandlerThread源码分析
public class HandlerThread extends Thread {
int mPriority;
int mTid = -1;
Looper mLooper;
public HandlerThread(String name) {
super(name);
mPriority = Process.THREAD_PRIORITY_DEFAULT;
}
以上代码可以看出,HandlerThread是一个线程。同时线程的优先级设置为默认优先级:Process.THREAD_PRIORITY_DEFAULT.
protected void onLooperPrepared() {
}
@Override
public void run() {
mTid = Process.myTid();
Looper.prepare();
synchronized (this) {
mLooper = Looper.myLooper();
notifyAll();
}
Process.setThreadPriority(mPriority);
onLooperPrepared();
Looper.loop();
mTid = -1;
}
/**
* This method returns the Looper associated with this thread. If this thread not been started
* or for any reason is isAlive() returns false, this method will return null. If this thread
* has been started, this method will block until the looper has been initialized.
* @return The looper.
*/
public Looper getLooper() {
if (!isAlive()) {
return null;
}
// If the thread has been started, wait until the looper has been created.
synchronized (this) {
while (isAlive() && mLooper == null) {
try {
wait();
} catch (InterruptedException e) {
}
}
}
return mLooper;
}
比较精彩的是这里run()以及getLooper()方法的设计。分析这段代码之前,我们要明白HandlerThread的使命:它是一个线程,帮我们自动建立好消息循环。OK,牢记这个使命这段代码就比较好懂了。有以下两个事实:
1)由于HandlerThread会和Handler联合起来使用,Handler会通过HandlerThread的getLooper()获取looper;
2)HandlerThread作为一个线程,要启动必须调用start()方法,start()方法调用以后,CPU调度线程以后,会自行run()方法。
run()方法的执行和getLooper()方法的调用是异步的。不管谁最先被调用,必须保证在调用getLooper()的时候,looper已经被初始化,否则就要等待looper被初始化。OK,明白这些隐含的规则以后,我们再来看代码实现。
run()方法中,会首先调用Looper.prepare(),然后执行looper的初始化,这里需要同步。基于前面的分析,run()和getLooper()调用时机异步,所以run()执行的时候,一旦looper初始化,就必须调用notifyAll(),通知被getLooper()阻塞的线程继续执行。
同时在getLooper()中,获取looper时,也必须同步,如果发现looper没有初始化,就wait()阻塞等待looper初始化完毕。
一个小的注意点: 从以上分析可知,一旦HandlerThread的run()没有执行,而先调用了getLooper(),那么调用getLooper()的线程会阻塞等待HandlerThread的start()被调用来触发looper初始化。所以如果getLooper()在主线程调用,为了获取最优性能,最好先调用HandlerThread的start(),然后再去调用getLooper(),如果getLooper()被调用以后,过了很久拆掉用HandlerThread的start(),会或多或少的导致主线程被阻塞一段时间。
public boolean quit() {
Looper looper = getLooper();
if (looper != null) {
looper.quit();
return true;
}
return false;
}
最后quit()方法,其实就是调用looper的quit来退出消息循环。避免消息循环一直在。所以HandlerThread使用完毕以后,要调用quit方法,否则会有内存泄漏。