Handler机制源码详解

PanhooCC
671 阅读6分钟

Handler对于Android系统来说可以是非常重要的了，因为它贯穿了整个Android系统，它随处可见，没有Handler，Android系统也就不起作用了。

流程介绍

Android系统是以消息驱动的，整个流程可以大致概括为：

发送消息 --> 添加消息到队列 --> 从队列中获取消息 --> 处理消息

上面的流程可以引出几个类分别是，发送消息的Handler，将消息Message发送到消息队列MessageQueue，Looper从消息队列循环取出消息，然后交给Handler处理。

在这里插入图片描述

  • Handler：消息发送和处理
  • Message：被发送和处理的消息
  • MessageQueue：存放消息的消息队列
  • Looper：循环的从MessageQueue中取消息给Handler处理

源码解析

发送消息

发送消息有send和post的方式：

// 发送消息
Handler handelr = new Handler();
// 发送方式一
handler.sendMessage(msg); // 或者handler.sendEmptyMessage(what);

// 发送方式二
handler.postXXX(runnable);

handler.sendXXX()和handler.postXXX()最终都会调用到sendMessageDelayed()方法。

public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis) {
    if (delayMillis < 0) {
    	delayMillis = 0;
    }
    // 注意sendMessageAtTime方法的第二个参数，当前时间加上延时时间
    return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}

然后调用了sendMessageAtTime方法

public boolean sendMessageAtTime(@NonNull 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); // uptimeMillis = SystemClock.uptimeMillis() + delayMillis
}

又调用了enqueueMessage()方法

private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg, long uptimeMillis) {
	msg.target = this;
	msg.workSourceUid = ThreadLocalWorkSource.getUid();

	if (mAsynchronous) {
		msg.setAsynchronous(true);
    }
	return queue.enqueueMessage(msg, uptimeMillis); // uptimeMillis = SystemClock.uptimeMillis() + delayMillis
}

然后又调用了MessageQueue的enqueueMessage()方法

boolean enqueueMessage(Message msg, long when) { // when = SystemClock.uptimeMillis() + delayMillis
	... // 省略无关代码
    synchronized (this) {
		...
            
        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)的时间(when)在所有消息队列的消息最前面，则把msg插入到队头,最先执行
            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) {
                    // 当p为空(遍历到最后一个了)，或者新消息的时间在p的时间之前，就不用再遍历了，因为可以确定新消息要插在消息p前面了
                    break;
                }
                if (needWake && p.isAsynchronous()) {
                    needWake = false;
                }
            }
            
            // break跳出for循环后执行到这里，将msg插入到p前面，prev后面
            msg.next = p; // invariant: p == prev.next
            prev.next = msg;
        }
		...
    }
    return true;
}

看Message类的实现可以看出它是个单链表，消息队列中的消息都是按照时间先后顺序链接起来的。

接下来详细分析一下上述代码，在if分支中有三个条件判断p == null || when == 0 || when < p.when，

  • p == null：当p也就是mMessages为空，表示消息队列中还没添加过消息
  • when == 0：when表示当前时间SystemClock.uptimeMillis()加上延迟时间delayMillis，所以when == 0这个条件应该是一直返回false
  • when < p.when：新消息的时间when小于p消息的时间p.when

以上三个条件只要满足任一条件都会执行到if代码块中的语句，将新消息添加到p消息的前面，p消息为空时，即队头。

当添加新消息时，消息队列中是有消息的，就会执行到else语句中。先来看看下面代码是什么意思：

prev = p;
p = p.next;

第一行代码中的p就是在if代码块中添加的消息，说明指针指向p消息，第二行代码又将指针指向了p消息的下一个消息。没错，指针向后移动了一位。为什么要这样呢？

从上面2行代码中可以看出，再次添加消息时，遍历消息都是从添加if代码块中的消息开始的，因为从if代码块中添加的消息要么就是第一个消息，要么就是when小于p消息的wnen的，也就是说可确保前面的消息都是时间有序递增的。而系统的时间是一直在增加的，所以enqueueMessage()方法的第二个参数when一直大于mMessages的when，所以要把指针向后移一位，从后面一个消息开始比对。

上图加深理解（图中所有msg的when为了偏于比较和理解，都是用的比较小的数字，而没有使用时间戳）：

在这里插入图片描述

添加第一个消息时，消息队列中是没有消息的，直接将消息msg1添加到消息队列的头部。

在这里插入图片描述

当添加第二个消息时，消息队列中已经有消息msg1，此时不满足if的条件，执行到else中的代码，因为p = mMessages，而mMessages在添加第一个消息时被赋值成了msg1，代码p = p.next将指针指向了msg1的下一个，也就是null，即p = null。当p == null时会跳出循环，会执行到

msg.next = p
prev.next = msg

也就是将msg2的下一个节点设置成p，即将msg2消息插入到p的前面。如下图： 在这里插入图片描述

上面添加的两个消息不是插入到队头就是队尾，再插入一个到中间的消息看看代码是怎么执行的。 在这里插入图片描述

因为mMessage只在添加msg1的时候被赋值了，所以p = mMessage = msg1，接下来执行if的判断条件if (p == null || when == 0 || when < p.when)，p = msg，when = 4，p.when = 1，不满足if条件，执行到else中的代码。

再来看else中的for循环，p = p.next将指针移到了msg2的位置，此时p = msg2，when = 4，p.when = 5，满足了for循环的if条件when < p.when

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;

将msg3插入到msg2前面，至此msg3的插入流程就走完了。

突然发现，好像除了添加msg1的时候执行到了if中的代码，后面都是执行else的代码。那在什么情况下会再次执行if中的代码呢？从if的条件中可以看出，此时p = msg1不会为空，when实际上是当前时间的时间戳，也不会等于0，所以只有当when < p.when的时候才会再次执行到if中的代码。

那再次发送一个消息msg4，假设msg.when = 0（实际上不会为0，这里为了方便假设为0，这个0不等于if条件中的0），满足条件后执行

msg.next = p;
mMessages = msg;

将msg4插入到p的前面，也就是msg1的前面了，然后又刷新了mMessages的值了。 在这里插入图片描述

总结
  • 添加第一个消息时，将消息添加到消息队列的队头
  • 再次添加消息时，先判断待添加消息的when和p.when的大小关系，小于p.when，则把消息添加到p的前面，否则循环消息队列找出合适的插入位置
  • 如果遍历完整个消息队列都没有满足条件的位置，则把新消息插入到队尾
  • 消息队列的消息按照时间从先到后排序

取出消息

开头说过整个系统是以消息驱动的，那么Looper就是其动力了，Looper.loop()方法不断的从MessageQueue中取消息。那么Looper.loop()方法是在哪里调用的呢？由于系统都是由消息驱动的，所以在系统启动的时候就应该有动力驱动了，在SystemServer.main()中调用了Looper.loop()，这是在系统层面的驱动，而对于APP应用层面来说，应用入口ActivityThread.main()中也需要调用Looper.loop()，毕竟APP也是需要各种事件响应的嘛。来看看loop()的代码：

public static void loop() {
	final Looper me = myLooper(); // 先获取Looper对象
	if (me == null) {
		throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
	}
	final MessageQueue queue = me.mQueue; // 获取消息队列，获取到了消息队列后才能从消息队列中取出消息

	... // 省略无关代码

	for (;;) {
		Message msg = queue.next(); // 获取消息，无消息时可能会阻塞
		if (msg == null) {
			// No message indicates that the message queue is quitting.
			return;
		}

		... // 省略无关代码
            
		// Make sure the observer won't change while processing a transaction.
		final Observer observer = sObserver;

		... // 省略无关代码

		Object token = null;
		if (observer != null) {
			token = observer.messageDispatchStarting(); // 开始分发消息
		}

		try {
			msg.target.dispatchMessage(msg); // 分发处理消息
			if (observer != null) {
				observer.messageDispatched(token, msg); // 消息分发处理完成
			}
			dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
		} catch (Exception exception) {
			if (observer != null) {
				observer.dispatchingThrewException(token, msg, exception); // 消息分发异常
			}
			throw exception;
		} finally {
		}
		... // 省略无关代码
		msg.recycleUnchecked(); // 回收消息
	}
}

首先要获取到Looper对象，当Looper对象为空时抛出异常No Looper; Looper.prepare() wasn't called on this thread.，我们就知道调用loop()方法之前需要先调用prepare()方法，在prepare()中创建出了Looper对象。

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

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

在创建Looper时创建了MessageQueue，sThreadLocal保证了一个线程只有一个Looper，而一个Looper又只有一个MessageQueue。

插入话题来看看ThreadLocal是怎么做到这些的。

回头看看prepare()方法，首先调用sThreadLocal.get()获取Looper，如果不为空说明已经创建过Looper了，为空就创建一个Looper保存在sThreadLocal中，看看sThreadLocal.get()的实现：

// 获取泛型T，这里是Looper
public T get() {
	Thread t = Thread.currentThread();
	ThreadLocalMap map = getMap(t);
	if (map != null) {
		ThreadLocalMap.Entry e = map.getEntry(this);
		if (e != null) {
			@SuppressWarnings("unchecked")
			T result = (T)e.value;
			return result;
		}
	}
	return setInitialValue();
}

// 获取当前线程的ThreadLocalMap
ThreadLocalMap getMap(Thread t) {
	return t.threadLocals;
}

// 当ThreadLocalMap为空时，设置初始值
private T setInitialValue() {
	T value = initialValue();
	Thread t = Thread.currentThread();
	ThreadLocalMap map = getMap(t);
	if (map != null)
		map.set(this, value);
	else
		createMap(t, value);
	return value;
}

protected T initialValue() {
    return null;
}

// 创建ThreadLocalMap
void createMap(Thread t, T firstValue) {
	t.threadLocals = new ThreadLocalMap(this, firstValue);
}

获取到当前线程，然后根据当前线程获取ThreadLocalMap，ThreadLocalMap是Thread的一个变量，表明一个线程只有一个ThreadLocalMap。接着判断ThreadLocalMap是否是空，为空则创建一个，否则就获取ThreadLocalMap中的值。再来看看sThreadLocal.set(T)方法：

# ThreadLocal.java
public void set(T value) {
	Thread t = Thread.currentThread();
	ThreadLocalMap map = getMap(t);
	if (map != null)
		map.set(this, value); // this就是sThreadLocal，static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
	else
		createMap(t, value);
}

set()方法中先是获取了当前线程，然后根据当前线程获取ThreadLocalMap，当map为空时就根据当前线程创建一个，否则就将value设置到map中。从map.set(this, value)可以看出，是用当前ThreadLocal对象sThreadLocal作为key，sThreadLocal是所有线程共享的，一个线程只有一个ThreadLocalMap，而一个ThreadLocalMap在key = this时只能获取到一个value。

再回头看看Looper.prepare()方法中的sThreadLocal.get()方法，从sThreadLocal.set()方法中我们已经知道了Looper和线程是一一对应的关系，从当前线程中获取的Looper不为空时就抛出异常，这样就避免了Looper再次创建。 在这里插入图片描述

话题转回来，获取到了looper对象后，就从looper中获取MessageQueue对象queue，然后在for(,,)循环中调用queue.next取消息，当消息队列中没有消息时，就会阻塞在queue.next()这里。来看看queue.next()中做了什么：

Message next() {
	... // 省略无关代码
        
	int nextPollTimeoutMillis = 0;
	for (;;) {
		if (nextPollTimeoutMillis != 0) {
			Binder.flushPendingCommands();
		}

		nativePollOnce(ptr, nextPollTimeoutMillis); // 休眠

		synchronized (this) {
			// Try to retrieve the next message.  Return if found.
			final long now = SystemClock.uptimeMillis();
			Message prevMsg = null; // 正常同步消息用不到这个
			Message msg = mMessages;
            // 当msg,target == null，表示这是同步屏障，msg就是优先执行的消息。
			if (msg != null && msg.target == null) {
				// Stalled by a barrier.  Find the next asynchronous message in the queue.
				do {
					prevMsg = msg;
					msg = msg.next; // 将同步屏障的异步消息放在队头，优先执行
				} while (msg != null && !msg.isAsynchronous());
			}
            
            // 主要看下面的代码
			if (msg != null) {
                // 代码片段1
				if (now < msg.when) {
					// Next message is not ready.  Set a timeout to wake up when it is ready.
                    // 当前时间大于消息的时间，说明还没有到该消息执行的时候，计算出消息执行的延时时间
					nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
				} else {
                    // 代码片段2
					// Got a message.
					mBlocked = false;
					if (prevMsg != null) {
						prevMsg.next = msg.next;
					} else {
						mMessages = msg.next; // msg将要进行处理，然后会将处理的消息删除，所以消息指针需要向后移一位
					}
					msg.next = null; // 表示将msg从消息队列中剔除
					if (DEBUG) Log.v(TAG, "Returning message: " + msg);
					msg.markInUse();
					return msg;
				}
			} else {
				// No more messages.
				nextPollTimeoutMillis = -1; // 没有消息，继续休眠等待
			}

			... // 省略无关代码
		}

		... // 省略无关代码
	}
}

next()里面是一个死循环，enqueueMessage()和next()方法中都用了同步锁，避免在发送消息时取消息以及取消息时发送消息，保证了线程安全。主要看synchronized(this)中的代码，首先获取到msg，就拿下图中发送的消息来看，此时的msg= mMessages = msg4，msg不为空，执行到代码片段1处，然后比较当前时间和msg.when的大小，如果now < msg.when，表明还没有到执行该消息的时候，计算出延迟执行时间；否则就执行代码片段2，prevMsg为空，所以执行mMessages = msg.next，将指针后移一位，即下图中的msg1处，然后执行msg.next = null，将msg4消息剔除。 在这里插入图片描述

这里要注意的是msg.next = null并不是将msg1设置为空的意思，而是将msg4与后面的消息节点断开连接。看下图 在这里插入图片描述

获取到消息之后会将消息返回，然后又回到了Looper.loop()方法的for(;;)中，返回的消息就是Message msg = queue.next();中的msg，然后将msg分发给handler处理，再次看上面的loop()方法，下面贴出关键代码：

try {
	msg.target.dispatchMessage(msg); // 分发处理消息
	if (observer != null) {
		observer.messageDispatched(token, msg); // 消息分发处理完成
	}
} catch (Exception exception) {
	...
} finally {
    ...
}

调用到msg.target.dispatchMessage(msg)方法，那msg.hander是什么呢？其实它就是Handler，还记得handler.enqueueMessage()方法吗？

#Handler.java
private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
		long uptimeMillis) {
	msg.target = this; // 在这里设置了target
	msg.workSourceUid = ThreadLocalWorkSource.getUid();

	if (mAsynchronous) {
		msg.setAsynchronous(true);
	}
	return queue.enqueueMessage(msg, uptimeMillis);
}
总结
  • 必须要先调用Looper.prepare()之后再调用Looper.loop()
  • 消息队列中没有消息的时候会堵塞在next()方法处让CPU休眠，不会ANR
  • 取到了消息后要判断当前时间和消息执行直接的先后关系，没到执行时间则继续休眠等待，否则就开始处理消息
  • 处理消息前，会将该消息从消息队列中剔除
  • 最后调用到handleMessage()方法处理消息（这条放在这里一起总结了）

处理消息

在Handler类中发送消息的时候就设置了msg.target，this指的就是当前的Handler对象。再次回到了Handler中，看看dispatchMessage做了什么事情。

public void dispatchMessage(@NonNull Message msg) {
	if (msg.callback != null) {
		handleCallback(msg);
	} else {
		if (mCallback != null) {
			if (mCallback.handleMessage(msg)) {
				return;
			}
		}
		handleMessage(msg);
	}
}

msg.callback是在创建Message的时候赋值的，而mCallback是在构造Handler的时候赋值的

public static Message obtain(Handler h, Runnable callback) {
	Message m = obtain();
	m.target = h;
	m.callback = callback; // 给msg.callback赋值

	return m;
}

public Handler() {
	this(null, false); // 默认callback为空
}

public Handler(@Nullable Callback callback, boolean async) {
	... // 省略无关代码
	mQueue = mLooper.mQueue;
	mCallback = callback; // 给mCallback赋值，默认为空
	mAsynchronous = async;
}

因此msg.callback和mCallback都为空，接下来执行到handleMessage(msg)方法

public void handleMessage(@NonNull Message msg) {
}

handleMessage方法是一个空实现方法，具体的实现在Handler的回调中

Handler handler = new Handler() {
	@Override
	public void handleMessage(@NonNull Message msg) {
		super.handleMessage(msg);
        // 实现具体的逻辑
	}
};

扩展

从dispatchMessage()中处理消息的地方有三处，默认调用的就是handleMessage(msg)，那什么时候调用其它2种方式呢？

  • handleCallback(msg)

当msg.callback不为空就会执行handleCallback(msg)，那么就需要先给msg.callback赋值了。上面说过msg.callback是在创建Message的时候赋值的，创建Message是通过Message.obtain()来创建的，来看看obtain方法的重载方法：

public static Message obtain(){}
public static Message obtain(Message orig){}
public static Message obtain(Handler h){}
public static Message obtain(Handler h, Runnable callback){}
public static Message obtain(Handler h, int what){}
public static Message obtain(Handler h, int what, Object obj){}
public static Message obtain(Handler h, int what, int arg1, int arg2){}
public static Message obtain(Handler h, int what, int arg1, int arg2, Object obj){}

obtain有8个重载方法，第四个重载方法可以设置msg.callback，那在创建Message的时候可以这样写：

Handler handler = new Handler();
Message message = Message.obtain(handler, new Runnable() {
	@Override
	public void run() {
	}
});
handler.sendMessage(message); // 发送消息

在Message obtain(handler, callback)中对msg.callback进行了赋值

public static Message obtain(Handler h, Runnable callback) {
	Message m = obtain();
	m.target = h;
	m.callback = callback; // 赋值
	return m;
}

然后在分发消息时会执行到handleCallback(msg)

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

最终会回调到创建Message时传入的第二个参数Runnable的run方法中。

  • mCallback.handleMessage(msg)

msg.callback的优先级最高，其次是mCallback，只有在msg.callback为空时才会执行到mCallback.handleMessage(msg)，所以在创建Message的时候不能再传入callback了。mCallback是在构造Handler的时候赋值的，所以要在创建Handler的时候就要传入mCallback。来看看Handler的构造函数：

public Handler(){}
public Handler(@NonNull Looper looper){}
public Handler(@NonNull Looper looper, @Nullable Callback callback){}
public Handler(boolean async){}
public Handler(@Nullable Callback callback){}
public Handler(@Nullable Callback callback, boolean async){} // @hide
public Handler(@NonNull Looper looper, @Nullable Callback callback, boolean async){}

`

Handler有7个构造函数，我们可以通过最简单的第五个构造函数来创建Handler：

Handler handler = new Handler(new Handler.Callback() {
	@Override
	public boolean handleMessage(@NonNull Message msg) {
		return false;
	}
});
Message message = Message.obtain(handler);
handler.sendMessage(message);

在Handler的构造函数中对mCallback进行了赋值，最终会调用到第六个被标上@hide的构造函数：

public Handler(@Nullable Callback callback, boolean async) {
	... // 省略无关代码
	mQueue = mLooper.mQueue;
	mCallback = callback; // 赋值
	mAsynchronous = async;
}

此时，msg.callback为空，mCallback不为空，就会调用mCallback.handleMessage(msg)方法，最后回调到了创建Handler的参数Handler.Callback的handleMessage(msg)中。

avatar
文章
阅读
粉丝
相关推荐
Handler三部曲（1）Handler源代码详细注解
308阅读
 · 
0点赞
Handler 源码解析（一）—— Handler 的工作流程
1.4k阅读
 · 
2点赞
Android源码阅读：Handler机制
622阅读
 · 
3点赞
Handler 同步屏障机制
806阅读
 · 
11点赞
handler源码解析
313阅读
 · 
0点赞
Handler 十连问
4.2k阅读
 · 
97点赞
Android Handler 源码解析
366阅读
 · 
5点赞
Netty 的 Handler 链调用机制
3.2k阅读
 · 
11点赞
Android源码—Handler
847阅读
 · 
8点赞
Handler-源码分析
2.7k阅读
 · 
12点赞

友情链接：