HandlerThread源码解析

其实从HandlerThread这个名字大家应该也能猜得出来，这是Handler和线程相关的类，如果你理解了Handler的机制，看起HandlerThread的源码其实很简单，其内部就几个简单方法，下面我一一解析一下。

一、继承关系

public class HandlerThread extends Thread {
        ······
}

通过上面的代码我们可以知道，HandlerThread其实就是一个Thread，只不过对Thread进行了扩展。

二、run()方法

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;
}

如果你了解过Handler，看了上面的的代码一定会会心一笑，就是通过Looper.prepare()这一行为当前的线程创建了一个Handler消息队列而已，然后通过Looper.loop()方法让消息队列循环起来。

三、获取当前HandlerThread的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;
}

上面的代码首先判断当前线程是否存活，如果已经死亡，直接返回null，如果是活动状态，等到mLooper不为null的时候，即在run()方法内完成初始化的时候，返回Looper。在使用时，我们在外部获取到HandlerThread的Looper之后，就可以通过Handler的构造方法将Looper传递到我们手写的Handler内部，来做消息的处理。（具体见最下方使用案例）

四、使用HandlerThread需要我们手动退出

public boolean quit() {
    Looper looper = getLooper();
    if (looper != null) {
        looper.quit();
        return true;
    }
    return false;
}

public boolean quitSafely() {
    Looper looper = getLooper();
    if (looper != null) {
        looper.quitSafely();
        return true;
    }
    return false;
}

如上所示，在quit()方法内会调用Looper的quit()方法，直接强制退出消息队列循环，不管还有没有待发送的消息。在quitSafely()方法内会调用Looper的quitSafely()方法，待消息队列中的所有消息处理完毕后，退出消息循环。

五、使用案例

public class MainActivity extends AppCompatActivity {

    private HandlerThread myHandlerThread;
    private Handler handler;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //创建一个线程,线程名字：handler-thread
        myHandlerThread = new HandlerThread("handler-thread");
        //开启一个线程
        myHandlerThread.start();
        //在这个线程中创建一个handler对象
        handler = new Handler(myHandlerThread.getLooper()) {
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                //这个方法是运行在 handler-thread 线程中的，可以执行耗时操作
                Log.d("handler", "消息：" + msg.what + "线程：" + Thread.currentThread().getName());
            }
        };

        //在主线程给handler发送消息
        handler.sendEmptyMessage(1);

        new Thread(new Runnable() {
            @Override
            public void run() {
                //在子线程给handler发送数据
                handler.sendEmptyMessage(2);
            }
        }).start();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();

        //释放资源
        myHandlerThread.quit();
    }
}

通过以上分析我们可以看到，HandlerThread帮我们封装了Lopper的创建调用，确保了使用HandlerThread创建的每个线程内部都默认创建了Looper。