Android 并发第五篇
本篇会讲解如何利用 HandlerThread 实现异步操作。
HandlerThread 本身其实就是一个 Thread ，但是其内部还利用 Handler 机制。
对于提交的任务（或者说是信息 Message）依次处理。
所以在介绍 HandlerThread 原理以及如果使用之前，会首先说一个 Handler 异步机制。
当然 Handler, Looper, Message 之间的关系相信很多人都已经很熟悉了，这里会只着重介绍和本节相关的内容。
一 、Handler 机制：
1、 我们都知道，在子线程中通知主线程更新UI界面，需要使用Handler。
一般我们就直接在 Activity 中直接 初始化一个Handler 对象,像这样：
Handler uiHandler = new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
}
};重写 handlerMessage() 方法，然后利用 uiHandler 对象在子线程中发送消息。
2、 或者我们也可以直接在主线程直接 new 一个 Handler 对象：
Handler handler = new Handler();但在子线程中 new Handler()需要这样：
Handler handler = new Handler(Context.getMainLooper());然后在子线程中：
handler.post(new Runnable() {
@Override
public void run() {
//执行在主线程中
Log.d(TAG, "run on UI Thread Id : "+Thread.currentThread().getId());
}
});Handler 源码：
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}在handler 中会将Runnable 对象赋值给 message.callback 属性，封装成Message,调用 sendMessageDelaye（） 将消息发送出去。
sendMessageDelaye() 方法最后在辗转几次后最终会调用sendMessageAtTime() 将消息放到消息队列中。
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
MessageQueue queue = mQueue;
if (queue == null) {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
return false;
}
return enqueueMessage(queue, msg, uptimeMillis);
}而 Handler.sendMessage()的源码为：
public final boolean sendMessage(Message msg)
{
return sendMessageDelayed(msg, 0);
}所以本质上，无论是利用Handler.sendMessage()，还是 Handler.post() 都是将消息添加到消息队列之中。
那么为什么在子线程中需要传入 MainLooper ， 而主线程却不需要呢？
首先我们是要在子线程中通知主线程，那么我们便需要代码执行在UI 线程中。
如果在子线程中直接：
Handler handler = new Handler();会抛出异常：
Can’t create handler inside thread that has not called Looper.prepare()
我们可以看一下源码：
Handler 源码：
public Handler() {
this(null, false);
}
public Handler(Callback callback, boolean async) {
if (FIND_POTENTIAL_LEAKS) {
final Class<? extends Handler> klass = getClass();
if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
(klass.getModifiers() & Modifier.STATIC) == 0) {
Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
klass.getCanonicalName());
}
}
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can‘t create handler inside thread that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}我们能够看到，无参的构造方法，会调用public Handler(Callback callback, boolean async) 。
在这个方法中，调用 Looper.myLooper(); 获取 Looper 对象，之所以抛出异常，一定是其为null了。
那么为什么没有获取到Looper对象呢？
接下来看Looper源码：
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}从 ThreadLocal 变量中获取当前线程的值，那么这个值是在哪里设置的呢？
public static void prepare() {
prepare(true);
}
private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(quitAllowed));
}
在Looper.prepare() 中设置的。
也就是说在子线程中直接 new Handler() 对象，需要先调用Looper.prepare() 方法。
而在主线程中是不需要的，因为在应用初始化时，已经调用 Looper.prepare() 了。
而Looper 中还有一个方法：Looper.loop() 方法
Looper.loop() 内包含一个死循环，不断的从队列中获取消息，如果没有消息时，会阻塞。
Looper.loop() 调用了 Handler.dispatchMessage() 方法：
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
private static void handleCallback(Message message) {
message.callback.run();
}在dispatchMessage() 方法中会调用 handleMessage() 方法，或者调用 handleCallback() 方法处理我们利用Handler post Runnable
所封装的消息。
3 、所以通过以上总结
我们知道如果Looper.loop()是在主线程中调用的，那么我们重写的 handlerMessage() 方法
和封装在消息中的 Runnable 都会在主线程中执行。
反过来说，如果Looper.prepare() 以及 Looper.loop() 是在子线程中调用的，那么基于子线程的Looper，所创建的Handler
所发送的消息都将会执行在子线程中，HandlerThread 便是利用了这个原理。
二 、HandlerThread
1 、我们首先看一下 HandlerThread 如何使用：
private void requestWithHandlerThread() {
//初始化一个 HandlerThread 对象
HandlerThread handlerThread = new HandlerThread("HandlerThread");
//调用start() 方法
handlerThread.start();
Log.d(TAG, "Main : "+Thread.currentThread().getId());
Log.d(TAG, "HandlerThread : "+handlerThread.getId());
//初始化一个Handler 对象，利用 HandlerThread 中的 Looper 对象
Handler handler = new Handler(handlerThread.getLooper()){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
//执行在子线程中
Log.d(TAG,"Thread : "+Thread.currentThread().getId() +" "+msg.obj);
}
};
Message message = Message.obtain();
message.obj = "From Message";
handler.sendMessage(message);
handler.post(new Runnable() {
@Override
public void run() {
//执行在子线程中
Log.d(TAG, "post : "+Thread.currentThread().getId());
}
});
}2 、结果：
11-15 17:20:15.634 12297-12297/com.loader.demo D/Demo: Main : 1
11-15 17:20:15.634 12297-12297/com.loader.demo D/Demo: HandlerThread : 26599
11-15 17:20:15.640 12297-12416/com.loader.demo D/Demo: Thread : 26599 From Message
11-15 17:20:15.640 12297-12416/com.loader.demo D/Demo: post : 26599在这里 HandlerThread 需要和 Handler 一起配合使用，HandlerThread 提供一个在子线程中创建的 Looper 。
按照之前的推论，Looper.prepare(), 以及 Looper.loop() 都是执行在子线程中，那么在处理消息时也必然执行在子线程中。
所以其实现了异步的效果。
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;
}
public HandlerThread(String name, int priority) {
super(name);
mPriority = priority;
}
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;
}
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;
}
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;
}
public int getThreadId() {
return mTid;
}
}
4 、总结
可以看到 HandlerThread 本身是一个 Thread 所以其 run() 方法会执行在子线程中。在 run() 方法中首先调用了Looper.prepare()，
用于初始化消息队列以及Looper对象，紧接着调用 Looper.loop() 开始从消息队列中轮询，一旦有消息便将消息取出处理。
因为整个过程都执行在子线程中，所以当我们用在子线程中创建的Looper作为参数传给Handler时，其处理消息的代码就会执行在子线程中了。
以上便是 HandlerThread 的原理，主要还是利用 Handler，Message, Looper 之间的关系。
三 、自定义 HandlerThread:
当我们了解了其原理之后，其实我们也可以自定义自己 HandlerThread ， 在线程之中处理消息。
现在我们自定义一个MyHandlerThread 同样继承 Thread。
1 、代码如下：
public class MyHandlerThread extends Thread {
private Handler asyncHandler;
private Looper mLooper;
public MyHandlerThread() {
}
@Override
public void run() {
Looper.prepare();
mLooper = Looper.myLooper();
synchronized (this) {
mLooper = Looper.myLooper();
notifyAll();
}
asyncHandler = new Handler(){
@Override
public void handleMessage(Message msg) {
handlerThreadMessage(msg);
}
};
Looper.loop();
}
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;
}
//退出
public void quit() {
Looper looper = getLooper();
if(looper != null) {
looper.quit();
}
}
/**
* 发送消息
* @param message
*/
public void sendMessage(Message message) {
if(asyncHandler != null) {
Log.d("test","sendMessage");
asyncHandler.sendMessage(message);
}
}
/**
* 处理消息
* @param message
*/
private void handlerThreadMessage(Message message) {
Log.d("test","Message : "+message.obj+" Thread " +Thread.currentThread().getId());
}
}2、用法也很简单：
定义变量：
private MyHandlerThread handlerThread;在onCreate() 中初始化：
handlerThread = new MyHandlerThread();
handlerThread.start();在需要异步时调用：
private void updateData() {
Message message = Message.obtain();
message.obj = "更新数据";
handlerThread.sendMessage(message);
}这样我们便实现自定义 HandlerThread ,其中我们还可以根据需求封装不同发送消息的方法。
并且我们还将提交任务的代码和在子线程中处理任务的代码分开了，两块代码利用 MessageQueue 相连接，
那么这是不是也算是一种生产者消费者模式呢？ 因为Handler 机制本身也算是一种生产者消费者模式啊。
四、
下一篇会讲解 Android 中另外一个可以实现异步的类： IntentService 。
IntentService 本身当然是一个 Service ， 但是它可以做到完成任务后自动退出，下一篇一起看看其是怎么做到的。