Handler机制的理解
开始文章前先说一些废话吧，本来原先就打算写Handler消息机制了，可惜自己以各种理由拖着，最后只能强逼着自己把这个文章写完，好勒，不啰嗦了，开始正文吧。
概述
Handler是Android提供给我们的一套消息机制，可以用来更新UI，也可以用来进行线程间的消息传递。
Handler的使用想必大家已经熟悉的不能再熟悉了，所以就不在多说。
先简单介绍一下涉及到的几个类：
Message:消息，在线程间进行通信的数据单元
MessageQueue:消息队列，主要功能是向消息池中添加消息和取走消息
Handler:处理消息事件，也将消息添加到消息队列中
Looper:不断循环遍历消息队列，分发给不同消息对应的Handler进行处理
再来一张图，帮我们理解下Handler的运行机制
接下来解释一下这张图：
1.Handler通过sendMessage方法发送消息，并调用enqueueMessage方法将消息加入到消息队列MessageQueue中。
2.Looper通过loop方法循环遍历消息队列，从队列MessageQueue中拿出消息Message，进行唤醒操作，然后调用Message对应的Handler里的dispatchMessage分发消息。
3.在Handler的handlerMessage方法中处理消息，这样就完成了一次消息的发送和处理过程。
Handler的运行机制大家稍微的了解了一下，接下来我们来看一下具体的代码实现，以下代码都是基于Android8.0的。
Message
public final class Message implements Parcelable{
//用去区分不同的消息
public int what;
//消息所携带的数据
public int arg1;
public int arg2;
public Object obj;
//消息所对应的Handler
Handler target;
//回调方法
Runnable callback;
//下一条Message
Message next;
//消息池
private static Message sPool;
//消息池的大小
private static int sPoolSize = 0;
//消息池最大可以存放消息的个数
private static final int MAX_POOL_SIZE = 50;
...
//从消息池中取出Message
public static Message obtain() {
synchronized (sPoolSync) {
if (sPool != null) {
Message m = sPool; //拿出消息池的队首消息
sPool = m.next; //将sPool指向下一个消息
m.next = null;
m.flags = 0;
sPoolSize--;
return m;
}
}
return new Message();
}
...
//回收消息，用于MessageQueue和Looper内部使用
void recycleUnchecked() {
...
synchronized (sPoolSync) {
if (sPoolSize < MAX_POOL_SIZE) { //当消息池存放的消息大于最大消息个数就不在存放了
next = sPool;
sPool = this;
sPoolSize++;
}
}
}
}Message通过next属性组成了一条单链表的结构，callback这个属性我们使用Handler进行post消息时会被赋值。
我们有时会用Message.obtain()来获取Message,从代码中可以看到从消息池中取出消息，返回给调用者，没有new一个返回给调用者。
MessageQueue
...
//加入到消息队列中
boolean enqueueMessage(Message msg, long when) {
if (msg.target == null) { //msg必须与handler绑定，要不然会抛出异常
throw new IllegalArgumentException("Message must have a target.");
}
if (msg.isInUse()) {
throw new IllegalStateException(msg + " This message is already in use.");
}
synchronized (this) {
if (mQuitting) { //如果正在退出时，回收msg，加入到消息池
...
msg.recycle(); //recycle方法最终调用的还是recycleUnchecked
return false;
}
msg.markInUse();
msg.when = when;
Message p = mMessages;
boolean needWake;
if (p == null || when == 0 || when < p.when) {
//p为null(代表MessageQueue没有消息） 或者msg的触发时间是队列中最早的还或者msg是立即要处理的
msg.next = p;
mMessages = msg;
needWake = mBlocked; //如果阻塞则进行唤醒
} else {
//needWake为ture的情况为阻塞状态并且p.target == null(我们自己发送的消息target是不能为null的，这个应该是系统发送的消息)还有就是msg为异步消息
needWake = mBlocked && p.target == null && msg.isAsynchronous();
//将消息按时间顺序插入到msg链表中
Message prev;
for (;;) {
prev = p;
p = p.next;
if (p == null || when < p.when) {
break;
}
if (needWake && p.isAsynchronous()) {
needWake = false;
}
}
msg.next = p;
prev.next = msg;
}
if (needWake) {
nativeWake(mPtr); //调用native层的唤醒操作
}
}
return true;
}
//获取下一个Message
Message next() {
final long ptr = mPtr;
if (ptr == 0) { //当native消息循环已经退出，则直接返回
return null;
}
int pendingIdleHandlerCount = -1; // 在第一次循环时pendingIdleHandlerCount才为-1
int nextPollTimeoutMillis = 0;
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
//阻塞操作，当nextPollTimeoutMillis=-1时阻塞，当为0时表示不阻塞，当为其他时间表示延时
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;
//查询异步消息
if (msg != null && msg.target == null) {
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous()); //当不在是异步消息时，退出循环
}
if (msg != null) {
if (now < msg.when) {
//当消息触发时间大于当前时间，则设置延时时间
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
//获取一个Message
mBlocked = false;
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;
if (DEBUG) Log.v(TAG, "Returning message: " + msg);
msg.markInUse();
return msg; //返回下一条消息
}
} else {
//没有Message则进行阻塞
nextPollTimeoutMillis = -1;
}
if (mQuitting) { //如果正在退出，则处理native层的消息队列，并返回null
dispose();
return null;
}
//在第一次循环是并且没有消息或者是一个延时消息
if (pendingIdleHandlerCount < 0
&& (mMessages == null || now < mMessages.when)) {
pendingIdleHandlerCount = mIdleHandlers.size();
}
if (pendingIdleHandlerCount <= 0) {
//继续循环并阻塞或者延时操作
mBlocked = true;
continue;
}
if (mPendingIdleHandlers == null) {
mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
}
mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
}
//只有第一次循环时，才会被运行
for (int i = 0; i < pendingIdleHandlerCount; i++) {
final IdleHandler idler = mPendingIdleHandlers[i];
mPendingIdleHandlers[i] = null;
boolean keep = false;
try {
keep = idler.queueIdle();
} catch (Throwable t) {
Log.wtf(TAG, "IdleHandler threw exception", t);
}
if (!keep) {
synchronized (this) {
mIdleHandlers.remove(idler);
}
}
}
//pendingIdleHandlerCount为0，下次将不再运行
pendingIdleHandlerCount = 0;
//当mPendingIdleHandlers操作完成以后，无需阻塞
nextPollTimeoutMillis = 0;
}
//移除消息
void removeMessages(Handler h, int what, Object object) {
if (h == null) {
return;
}
synchronized (this) {
Message p = mMessages;
//循环遍历消息队列，移除连续的符合条件的消息
while (p != null && p.target == h && p.what == what
&& (object == null || p.obj == object)) {
Message n = p.next;
mMessages = n;
p.recycleUnchecked();
p = n;
}
//再循环遍历剩下的消息，移除符合条件的消息
while (p != null) {
Message n = p.next;
if (n != null) {
if (n.target == h && n.what == what
&& (object == null || n.obj == object)) {
Message nn = n.next;
n.recycleUnchecked();
p.next = nn;
continue;
}
}
p = n;
}
}
}
...MessageQueue中唤醒的方法是nativeWake()，底层是epoll机制（一种IO多路复用机制），通过往pipe管道写端写入数据来唤醒线程工作。阻塞方法是nativePollOnce()方法，该方法会使线程释放CPU资源进入休眠状态，直到下个消息到达，才会被唤醒。
Looper
...
//初始化一个消息队列，并获取当前的线程，quitAllowed表示消息队列是否可以退出
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
public static void prepare() {
prepare(true);
}
//将当前的Looper与当前线程绑定，并且一个线程只能绑定一个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));
}
...
//初始化应用的主线程Looper
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
//返回主线程的Looper
public static Looper getMainLooper() {
synchronized (Looper.class) {
return sMainLooper;
}
}
//循序遍历消息队列
public static void loop() {
final Looper me = myLooper(); //从ThreadLocal中取出当前线程绑定的Looper
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue;
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
for (;;) {
Message msg = queue.next(); //取出消息队列中的下一条消息
if (msg == null) {
//没有消息则退出
return;
}
...
try {
msg.target.dispatchMessage(msg); //调用msg中的handler分发消息
end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
msg.recycleUnchecked(); //将msg存放到消息池中
}
}
...
Looper的prepareMainLooper在app一开始运行时，就在ActivityThread中被调用了，这也就是我们可以在主线程中直接创建一个Handler而不报错的原因，如果要在自己的线程中使用Looper，就要调用的Looper.prepare方法，将Looper与当前线程绑定。
Handler
...
//Handler构造方法
public Handler(Callback callback, boolean async) {
//匿名类、内部类或本地类用static进行修饰，要不然会提示警告
if (FIND_POTENTIAL_LEAKS) {
final Class 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());
}
}
//获取当前线程的Looper与Handler绑定
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
//获取MessageQueue与当前Handler绑定
mQueue = mLooper.mQueue;
mCallback = callback; //会调用方法
mAsynchronous = async; //设置消息是否异步处理
}
//post消息
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}
//获取callback被赋值的Message
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
//发送消息
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) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true); //设置消息为异步消息
}
return queue.enqueueMessage(msg, uptimeMillis);
}
//消息的分发，在Looper中next方法中调用的
public void dispatchMessage(Message msg) {
if (msg.callback != null) { //调用Message中的callback
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) { //调用Handler中的callback
return;
}
}
handleMessage(msg); //调用handleMessage方法
}
}Handler有多个构造方法，最终调用的是Handler(Callback callback, boolean async) 这个构造方法。使用post发送消息时，会调用getPostMessage方法获取一个callback被赋值了的Message,然后调用sendMessageDelayed方法，而sendMessageDelayed最终调用的还是sendMessageAtTime这个方法。我们常用的sendEmptyMessage和sendEmptyMessageDelayed还有sendMessageDelayed方法最终调用的也是sendMessageAtTime这个方法。
ActivityThread
下面这段代码是ActivityThread中Looper被初始化的代码
public static void main(String[] args) {
...
//主线程中初始化Looper
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
// End of event ActivityThreadMain.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
//开始Looper循环
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
总结
通过对涉及到的源码进行分析，我们可以知道:
1.每个线程中只能有一个Looper
2.每个Looper只有一个MessageQueue
3.Looper和Handler是在同一个线程中