前言
Handler是一项很重要的技术，它的使用地方很多，使用的时候我们很多是创建一个Handler对象，重写handleMessage()方法，但原理是什么，还是需要认真研究下~
一：关联类的名称以及作用
Message：消息，其中包含了消息ID，消息处理对象以及处理的数据等，由MessageQueue统一列队，终由Handler处理
Handler：：处理者，负责Message的发送及处理。使用Handler时，需要实现handleMessage(Message msg)方法来对特定的Message进行处理，例如更新UI等
MessageQueue：消息队列，用来存放Handler发送过来的消息，并按照FIFO规则（先进先出）执行
Looper ：让MessageQueue动起来
二：从ActivityThread的main()方法说起
ActivityThread的main()方法是程序的入口，我们看下关于Looper、Handler的这部分做了些什么
...省略
//创建一个主线程Looper对象保存在TheadLocal中
Looper.prepareMainLooper();
...省略
ActivityThread thread = new ActivityThread();
thread.attach(false, startSeq);
//创建了一个主线程Handler对象
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
//开始从MessageQueue中抽取Message
Looper.loop();
在开始分析之前，我们先看下Looper类对象的成员
public final class Looper {
private static final String TAG = "Looper";
//静态的ThreadLocal<Looper>对象
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
//主线程Looper对象
private static Looper sMainLooper; // guarded by Looper.class
//当前线程消息队列
final MessageQueue mQueue;
//当前线程
final Thread mThread;
其中sMainLooper是在prepareMainLooper中初始化赋值
mQueue和mThread是在构造函数中初始化的
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
关于ThreadLocal，大家可以参考这两篇文章：
ThreadLocal是什么
ThreadLocal和synchronized区别
Looper.prepareMainLooper()调用了prepare()方法，然对sMainLooper 对象判空，如果不为空，那么抛出异常
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
可以看到，prepare()方法把当前Looper存放到了ThreadLocal中
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.looper()方法从Messagequeue中获取Message，然后执行msg.target.dispatchMessage(msg)，把消息分发出去
public static void loop() {
//从ThreadLocal中获取到当前线程的Looper
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
//获取当前Looper中的MessageQueque
final MessageQueue queue = me.mQueue;
...省略
//开始循环
for (;;) {
//链表中获取到一个Message
Message msg = queue.next(); // might block
if (msg == null) {
...省略
try {
//Meesage的target(该对象就是Message持有的Handler对象)
msg.target.dispatchMessage(msg);
dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
} finally {
...省略
//对已经分发的消息进行回收操作，实际上是把Message的对象制空，标识，参数清零等操作
msg.recycleUnchecked();
}
}
关于dispatchMessage()方法，稍后具体分析
通过以上流程，我们大致了解了这几个东西到底是干些什么的
三：关于Handler
我们先从Handler.class的成员变量、构造方法开始看起
以下是Handler中比较重要的成员变量
final Looper mLooper;
final MessageQueue mQueue;
final Callback mCallback;
final boolean mAsynchronous;
IMessenger mMessenger;
来看下构造函数
构造函数有很多个，但最终都是调用到这个构造函数
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());
}
}
//获取到当前线程的Looper，给当前线程的Looper赋值
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread " + Thread.currentThread()
+ " that has not called Looper.prepare()");
}
//获取到当前Looper的MessageQueue,并指向当前Handler的queue
mQueue = mLooper.mQueue;
//给回调这个成员变量赋值
mCallback = callback;
mAsynchronous = async;
}
我们来看下刚才说到的dispatchMessage()方法
public void dispatchMessage(Message msg) {
//如果message对象的CallBack不为null，那么执行messageCallback
if (msg.callback != null) {
handleCallback(msg);
} else {
//如果Handler类构造函数传入的callBack不为null，那么执行这个callBack
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
//如果都不满足，那么执行这个函数
handleMessage(msg);
}
}
那么handlerMessage()是什么我们不用过多解释了，继承一个Handler都要重写的方法，最后的回调，也是上面的逻辑
四：怎么发送一个Message
我们还是先来看下Message这个类的重要成员
/*package*/ int flags;
/*package*/ long when;
/*package*/ Bundle data;
/*package* handler对象/ Handler target;
/*package* 回调/ Runnable callback;
// sometimes we store linked lists of these things
/*package* 指针/ Message next;
/** @hide * 类锁/
public static final Object sPoolSync = new Object();
一般发送Message有两种方式
第一种：创建一个Message
Message message = new Message();
message.what = 1;
mHandler.sendMessage(message);
第二种：获取一个Message
Message message = mHandler.obtainMessage();
message.what = 1;
message.sendToTarget();
这两种的区别就是：前者是新创建一个Message加入MessageQueue，后者是从整个Messge池中返回一个新的Message实例
不论是sendMessage或者sendToTarget最后都会执行到Handler类的enqueueMessage方法，这个方法给Message的Handler对象target赋值,然后执行MessageQueue的enqueueMessage方法
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
五:MessageQueue的入队和出队
enqueueMessage()方法也就是我们常说的”入队“，把当前这个Message放入MessageQueue的合适位置
boolean enqueueMessage(Message msg, long when) {
if (msg.target == null) {
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) {
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 {
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) {
nativeWake(mPtr);
}
}
return true;
}
先看下新消息需要放到队头的情况：p == null || when == 0 || when < p.when。即队列为空，或者新消息需要立即处理，或者新消息处理的事件比队头消息更早被处理。这时只要让新消息的next指向当前队头，让mMessages指向新消息即可完成插入操作。
除了上述三种情况就需要遍历队列来确定新消息位置了，下面结合示意图来说明。
假设当前消息队列如下
开始遍历：p向队尾移，引入prev指向p上一个元素
假设此时p所指消息的when比新消息晚，则新消息位置在prev与p中间
最后便是调用native方法来唤醒
Looper.loop()中调用到MessageQueue的next()方法是我们常说的出队
Message next() {
...省略
int pendingIdleHandlerCount = -1; // -1 only during first iteration
int nextPollTimeoutMillis = 0;
for (;;) {
...省略
synchronized (this) {
// Try to retrieve the next message. Return if found.
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;
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) {
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 {
// Got a message.
mBlocked = false;
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
//取出一个Message
mMessages = msg.next;
}
msg.next = null;
if (DEBUG) Log.v(TAG, "Returning message: " + msg);
msg.markInUse();
return msg;
}
} else {
// No more messages.
nextPollTimeoutMillis = -1;
}
...省略
}
}
可以看到这里就成功取出了一个Message
至此，关于Looper、MessageQueue、Handler就分析的差不多了
End
In the bleak midwinter...--《Peaky fucking Blinders》
