Handler异步消息处理机制的源码分析

1. Handler异步消息处理机制

主线程不能进行耗时操作 (会发生ANR异常)

子线程不能更新UI的操作 （因为会报异常——>只有产生该控件的线程才能操作该控件。）

那么 , 要在子线程请求数据，然后将数据发送到主线程中更新UI , 此时需要使用Handler机制.

2. Handler的核心组成部分

Handler : 用于发送消息和处理消息

Message : 用于携带数据和通知

MessageQueue : 以单链表的形式用于存储消息

Looper : 死循环，如果消息队列里有消息就将其取出然后交给对应的Handler处理，如果没有就处于等待状态

3. Handler的异步消息处理流程图

首先需要在主线程中创建一个Handler对象 , 并重写handleMessage()方法 , 然后当子线程中需要进行UI操作时 , 就创建一个Message对象 , 并通过Handler将这条
4000
信息发送出去 , 之后这条信息会被添加到MessageQueue的队列中等待被处理 , 而Looper则会一直尝试从MessageQueue中取出待处理消息 , 最后分发会Handler的handlerMessage()方法中.由于Handler是在主线程中创建的 , 所以此时handlerMessage()方法中的代码也会在主线程中运行 , 进行UI操作.



异步消息处理线程启动后会进入一个无限的循环体之中，每循环一次，从其内部的消息队列中取出一个消息，然后回调相应的消息处理函数，执行完成一个消息后则继续循环。若消息队列为空，线程则会阻塞等待。

4. Handler的简单使用方法

在主线程中创建一个Handler对象 , 重写里面的方法

// 创建一个Handler对象
private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
// 处理消息
}
};

在子线程中通过mHandler发送信息

// 创建一个Message对象
Message msg = Message.obtain();
// 将消息存入Message对象中
msg.obj = null;
// 给消息添加标记 , 例如 SUCCESS 和 FAILED
msg.what = 0;
// 通过mHandler发送消息到主线程
mHandler.sendMessage(msg);

在主线程中进行操作

handle.post(new Runnable() {
@Override
public void run() {

}
});

5. Handler的源码分析

(1) 首先 , 我们来看看Message对象的创建 , 一共有3种方式

Message msg = new Message();
Message msg = Message.obtain();
// 发送消息
handler.sendMessage(msg);

// handler已经绑定
Message msg = handler.obtainMessage();
// 发送消息
msg.sendToTarget();

handler.obtainMessage()方法里底层实质上也是调用了Message的obtain(handler)方法 , 然后通过sendToTarget()发送出去

public final Message obtainMessage()
{
return Message.obtain(this);
}

Message继承了Parcelable接口 , 可实现序列化 , 那么 , 接下来 , 我们看看Message对象里的obtain()方法 , 里面到底做了什么 :

public final class Message implements Parcelable

/*package*/ Message next;
private static final Object sPoolSync = new Object();
private static Message sPool;
private static int sPoolSize = 0;
private static final int MAX_POOL_SIZE = 50;

public static Message obtain() {
synchronized (sPoolSync) {
if (sPool != null) {
Message m = sPool;
sPool = m.next;
m.next = null;
m.flags = 0; // clear in-use flag
sPoolSize--;
return m;
}
}
return new Message();
}

从中可以看到一个同步块 , 通过一个new的object对象进行加锁 , 然后 , 在同步块里 , 如果sPool不为null , 那么将sPool赋值给了m , 最后返回出来 , 如果sPool为null , 那么就重新new一个Message对象.

这时 , 大家一定奇怪了 , 第11行和第12行的这两行代码又代表着什么 , 其实 , 这里消息池是一个单链表结构 , 这两行代码意味着从消息池中取出Message对象后 , 对sPool的位置进行重置.

然后 , 我们再来看Message的obtain(Handler h)方法 :

public static Message obtain(Handler h) {
Message m = obtain();
m.target = h;

return m;
}

其中 , target就是对Handler进行标记 , 比如一个应用中创建了多个Handler对象来发送消息 , 那么就可以用target来进行区分.

好 , 我们接下来再看一下Message里的recycle()方法 , 对消息进行回收 , 里面的属性都设置为默认值 :

public void recycle() {
...
recycleUnchecked();
}

void recycleUnchecked() {
// Mark the message as in use while it remains in the recycled object pool.
// Clear out all other details.
flags = FLAG_IN_USE;
what = 0;
arg1 = 0;
arg2 = 0;
obj = null;
replyTo = null;
sendingUid = -1;
when = 0;
target = null;
callback = null;
data = null;

synchronized (sPoolSync) {
if (sPoolSize < MAX_POOL_SIZE) {
next = sPool;
sPool = this;
sPoolSize++;
}
}
}

(2) 我们再走进Handler对象中 , 切入主入口 , Handler的实例化

public Handler() {
this(null, false);
}

实质上是调用了它的重载方法 , 传入两个参数 , null 和 false , 如下 :

public Handler(Callback callback, boolean async) {
// 此处省略一万行代码
...

// 轮询器,轮询取消息
mLooper = Looper.myLooper();

// 消息队列,存放handler发的消息
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}

关键的部分来了 , 第6行和第9行代码 , 获取了轮询器的对象mLooper , 以及消息队列mQueue , 此处表示handler和mLooper共享同一个消息队列 . 那我们首先来看mLooper的初始化 , Looper.myLooper()方法 :

// sThreadLocal.get() will return null unless you've called prepare().
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
/**
* Return the Looper object associated with the current thread.  Returns
* null if the calling thread is not associated with a Looper.
*/
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}

其中 , sThreadLocal是代表本地线程变量 , 每个线程都可以去调用它 , 它也知道是哪个线程在存放数据 , 那么这里的get()方法 , 就是去获取数据 , 这时 , 你一定奇怪它是什么时候存的呢?这里要提到一个ActivityThread类 , 代表主线程 , 在应用程序运行之前 , ActivityThread类就已经初始化了 , 我们来看里面的核心代码 :

//主线程
public static final void main(String[] args) {
。。。
//轮询器的初始化
Looper.prepareMainLooper();

。。。
//轮询器开始取消息
Looper.loop();

}

其中 , prepareMainLooper()里面实质是调用了prepare()方法

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

可以看到 , sThreadLocal.set()方法添加了一个新的Looper对象 , 也就是说 , 在创建Handler之前 , UI线程中就已经调用了Looper.prepare()和Looper.loop()方法. 在看Looper.loop()方法之前 , 我们先看一下Looper的构造方法 , 因为在主线程中已经创建了一个Looper对象

private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}

从上面的构造函数中可以看到 , Looper在初始化时 , 就默认创建了一个消息队列对象MessageQueue.

MessageQueue(boolean quitAllowed) {
mQuitAllowed = quitAllowed;
mPtr = nativeInit();
}

那我们再来看一下Looper.loop()方法 , 轮询取消息了 , 不过还没有发送消息 , 这时是取不到消息的

public static void loop() {
// 当前是主线程,只有一个Looper对象,同handler一起共享
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
// 与handler共享同一个消息队列
final MessageQueue queue = me.mQueue;

// Make sure the identity of this thread is that of the local process,
// and keep track of what that identity token actually is.
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();

for (;;) {
// 核心代码,无限循环取消息了,如果没有消息,系统有可能阻塞
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}

...
msg.target.dispatchMessage(msg);

...
msg.recycleUnchecked();
}
}

代码比较多 , 其实核心代码就几个 , 其中Message msg = queue.next() , 从系统运行开始就一直无限循环取消息 , 所以当消息为null时 , 可能会造成阻塞. 那我们来看一下next()方法里是什么

Message next() {
...

// 代码太多,但是看到这一行代码就足够了
nativePollOnce(ptr, nextPollTimeoutMillis);

...
}

这里就涉及到JNI机制了 , 底层的通信交给本地代码了

private native static long nativeInit();
private native static void nativeDestroy(long ptr);
private native void nativePollOnce(long ptr, int timeoutMillis); /*non-static for callbacks*/
private native static void nativeWake(long ptr); // 唤醒
private native static boolean nativeIsPolling(long ptr);
private native static void nativeSetFileDescriptorEvents(long ptr, int fd, int events);

这里扩展一下 , inux进程间的通信，linux管道通讯，管道其实就是个特殊的文件，该文件有两个描述符（操作文件的句柄（引用）），读的描述符，写的描述符

通讯的原型

主线程拿着读的描述符等待读取数据，子线程拿着写的描述符开始写数据，写完数据之后通知拿着读描述符的主线程，主线程唤醒，开始轮询取消息，处理消息，如果没有消息中断（阻塞）

(3) 发送消息

调用handle.sendMessage(msg);

public final boolean sendMessage(Message msg)
{
return sendMessageDelayed(msg, 0);
}

public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}

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

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
// handler发送消息,把当前的handler对象绑定到message对象中
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
// 把消息放到消息队列里,并排序
return queue.enqueueMessage(msg, uptimeMillis);
}

感觉发消息发了好久 , 上面的sendMessageDelayed()方法可以延迟发消息 , 最终实质上是调用了queue.enqueueMessage(msg, uptimeMillis)方法 , 把消息放到消息队列里,并排序.

boolean enqueueMessage(Message msg, long when) {
// this表示同一个容器,消息队列
synchronized (this) {
if (mQuitting) {
IllegalStateException e = new IllegalStateException(
msg.target + " sending message to a Handler on a dead thread");
Log.w(TAG, e.getMessage(), e);
msg.recycle();
return false;
}

msg.markInUse();
// 延迟时间
msg.when = when;
Message p = mMessages;
boolean needWake;
if (p == null || when == 0 || when < p.when) {
// New head, wake up the event queue if blocked.
msg.next = p;
mMessages = msg;
needWake = mBlocked;
} else {
// Inserted within the middle of the queue.  Usually we don't have to wake
// up the event queue unless there is a barrier at the head of the queue
// and the message is the earliest asynchronous message in the queue.
needWake = mBlocked && p.target == null && msg.isAsynchronous();
Message prev;
for (;;) {
prev = p;
p = p.next;
if (p == null || when < p.when) {
break;
}
if (needWake && p.isAsynchronous()) {
needWake = false;
}
}
msg.next = p; // invariant: p == prev.next
prev.next = msg;
}

// We can assume mPtr != 0 because mQuitting is false.
if (needWake) {
// 唤醒jni
nativeWake(mPtr);
}
}
return true;
}

(4) 取消息

又回到上面的Looper.loop()方法了 , 精简版

public static void loop() {
final Looper me = myLooper();

final MessageQueue queue = me.mQueue;

for (;;) {
// 取消息
Message msg = queue.next(); // might block
if (msg == null) {

return;
}
// 处理信息
msg.target.dispatchMessage(msg);

...
msg.recycleUnchecked();
}
}

走到这一步了 , 让我们来看看handler最后是如何处理消息的 , msg.target.dispatchMessage(msg) , 注意的是 , 该方法是在主线程中运行的 , 因为loop()方法就是在主线程中运行

public void dispatchMessage(Message msg) {
// 发送信息时,默认msg.callback为null
if (msg.callback != null) {
// 处理runOnUiThread方法
handleCallback(msg);
} else {
// 我们走这里,msg.callback==null
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
// 主线程,方法回调
handleMessage(msg);
}
}

最后回调给了主线程中的handler的handleMessage()方法 , 这就是Handler异步消息处理机制的全过程.

6. runOnUiThread方法的源码分析

实质上也是调用了Handler的post方法

public final void runOnUiThread(Runnable action) {
if (Thread.currentThread() != mUiThread) {
// 关键点
mHandler.post(action);
} else {
action.run();
}
}

接下来我们深入看下Handler的post方法的代码逻辑

public final boolean post(Runnable r)
{
return  sendMessageDelayed(getPostMessage(r), 0);
}

看到sendMessageDelayed()方法是不是有种很亲切的感觉 , 跟上面不同 , 此时传入的第一个参数msg为getPostMessage(r)

private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}

那么 , 重点来了 , 返回一个新的Message对象 , 只是多添加了一个callback属性 , callback不再为null , 走到最后的handler.dispatchMessage(msg)方法

public void dispatchMessage(Message msg) {
// 此时,msg.callback不为null
if (msg.callback != null) {
// 处理runOnUiThread方法
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}

此时 , msg.callback不为null , 那么就走handleCallback(msg)方法

private static void handleCallback(Message message) {
message.callback.run();
}

这里的message.callback就是传入的Runnable , 它本身跟线程是没有任何关系的 , 之所以会在主线程中运行 , 完全是因为dispatchMessage()方法是在主线程中运行的 , 然后调用Runnable.run()方法.

欢迎大家交流 , 共同探讨!