本篇文章是对Handler的源码分析
写在前面
对于一名开发者，阅读源码是一项必修的课程。从源码的过程中，我们可以了解到设计模式与源代码开发者的开发习惯。而在阅读源码的过程中，我一直秉承着郭霖大神的那句话“抽丝剥茧、点到即止”，我们没有必要完全深入每一行代码，通常我们可能只需要知道这一行代码的作用就行了。
如果本文出现错误，请及时在评论中提醒我，谢谢！
分析的过程
建议没有看过的同学可以根据以下的流程进行相应的查看源码
Handler的初始话 Handler()(Handler.java)->Handler(Callback callback, boolean async)
Handler发送消息 sendMessage()(Handler.java)->sendMessageDelayed()->sendMessageAtTime()->enqueueMessage()(MessageQueue.java)->MessageQueue.next()
通过handler已知的方法反推 handleMessage()->dispatchMessage()->Looper.loop()（Loop.java）
具体分析的过程
回想一下，在使用handler的过程中，我们分为以下几步首先我们要创建一个handler
Handler handler=new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
}
};
然后发送信息
Message message=handler.obtainMessage();
message.what=1;
message.arg1=i;
message.obj="倒计时：";
handler.sendMessage(message);handler处理消息
Handler handler=new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
int arg1=msg.arg1;
String info= (String) msg.obj;
if (msg.what==1){
textView.setText(info+arg1);
}
if (arg1==0){
textView.setText("完成");
}
}
};
这样就完成了一次完整的handler消息传递
那么我们就根据这样的步骤进行源码查看
第一步：创建Handler
调用了这个类的另一个构造方法
到这里，handler的初始化就完毕了。这里的代码做了什么呢？我们一起看一下：
这个方法在198行获取了一个mLooper，然后又取了mLooper中的mQueue作为Handler的成员变量，就结束了。
这里我们需要重点关注一下Looper.myLooper。
这里就涉及到ThreadLocal的知识（ThreadLocal在多线程开发的过程中有着至关重要的作用，强烈建议同学们去了解一下），为了方便我们可以粗暴的把这个理解成为线程安全的HashMap，可以根据执行这个方法的线程获取出对应的对象。这里的话get的就是Looper，这也从侧面证明了一点：一个线程对应一个Looper。
思考一个问题，这里既然有个get，那是不是也会有set呢？ 我们搜一下，果然找到了
这里我们set进去一个新创建的Looper（同时我们的也可以看到MessageQueue也是在这里进行初始化创建的）
由这个方法名，我们想到之前在抛出来的那个runtimeException
验证了一个问题，在初始话Handler之前我们需要调用Looper.prepare这个方法。那我们平时用的时候，Looper在哪里调用的perpare呢？
想一下我们用的Handler，通常都是在UI线程（主线程里面的），那我们去ActivityThread找一下看看，结果在main方法里面找到了
public static void main(String[] args) {
...
Environment.initForCurrentUser();
EventLogger.setReporter(new EventLoggingReporter());
final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
TrustedCertificateStore.setDefaultUserDirectory(configDir);
Process.setArgV0("<pre-initialized>");
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.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}main方法有行代码为Looper.prepareMainLooper()，感觉很像啊，我们点进去看看，好像里面就是调用了Looper的prepare方法，所以在我们初始话handler之前，系统已经帮我们初始话好了一个Looper，这样就不需要我们自己去prepare了。
第二步 通过handler发送信息
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);
}我们查阅源码可以知道，所有的sendMessage最后都会进入到sendMessageAtTime这个方法里面去，这个方法有两个参数，一个是所需要传递的message对象，另一个根据上下文可得知是展示这个message的时间，我们在进入到enqueueMessage这个方法里面去看看
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}这个方法就比较重要了，首先对msg设置了一个target，这个this代表了当前的handler对象。这一步是保证handler能在所在的线程中获取结果的关键（个人认为类似于回调）
我们在进入到 queue.enqueueMessage 这个方法里面去看看
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 {
// 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) {
nativeWake(mPtr);
}
}
return true;简单的解释一下，这段代码的意思简单的说就是把message放入到messagequeue中，然后等待Looper处理。那到底怎么放呢？我们详细的看一下，首先判断这个msg是否是已经用过的，如果用过的代码这里就直接抛出了个异常(这说明了每个msg只能被用一次，如何确定这个msg使用过的是通过msg中的一个int类型的成员变量)。然后将这个msg设为已用，并将它与之前的msg进行比较，比较的依据即是when（消息待处理的时间），如果when比我们传入msg的when要早就进行，那就行对msg位置的迁移。
这里要说明一下，虽然名称是叫做MessageQueue，但是MessageQueue并不是一个queue，他是一个单向的链表，具体的事项方式是在Message.java中
每一个message都有一个指向下一个message的处对象，这样就形成了一个单项的链表。
再回到 enqueueMessage 这个方法里面，那这个排序的方法就可以了理解了吧
for (;;) {
prev = p;
p = p.next;
if (p == null || when < p.when) {
break;
}
if (needWake && p.isAsynchronous()) {
needWake = false;
}
}我们继续看下去
if (needWake) {
nativeWake(mPtr);
}这个nativeWake的作用就是唤醒线程。至于在哪里进行唤醒，我们将在第三步揭晓。
第三步 发送信息
由于这个方法不太好找，我们采用反推的反推的方式进行查看源码
首先我们根据handleMessage方法，找到了dispatchMessage()这个方法。这个两个方法都是传递消息的基础方法，这里就不讲解了
public void handleMessage(Message msg) {
}
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}接下来我们用dispatchMessage这个方法名在相关的几个类中搜索，结果在Looper.java的loop中找到了。由于这个方法较长，我选取了部分我们主要关注的进行查看。
public static void loop() {
final Looper me = myLooper();
final MessageQueue queue = me.mQueue;
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
final int thresholdOverride =
SystemProperties.getInt("log.looper."
+ Process.myUid() + "."
+ Thread.currentThread().getName()
+ ".slow", 0);
boolean slowDeliveryDetected = false;
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
return;
}
final long traceTag = me.mTraceTag;
long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;
long slowDeliveryThresholdMs = me.mSlowDeliveryThresholdMs;
if (thresholdOverride > 0) {
slowDispatchThresholdMs = thresholdOverride;
slowDeliveryThresholdMs = thresholdOverride;
}
final boolean logSlowDelivery = (slowDeliveryThresholdMs > 0) && (msg.when > 0);
final boolean logSlowDispatch = (slowDispatchThresholdMs > 0);
final boolean needStartTime = logSlowDelivery || logSlowDispatch;
final boolean needEndTime = logSlowDispatch;
if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
final long dispatchStart = needStartTime ? SystemClock.uptimeMillis() : 0;
final long dispatchEnd;
try {
msg.target.dispatchMessage(msg);
dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
} finally {
}
if (logSlowDelivery) {
if (slowDeliveryDetected) {
if ((dispatchStart - msg.when) <= 10) {
slowDeliveryDetected = false;
}
} else {
if (showSlowLog(slowDeliveryThresholdMs, msg.when, dispatchStart, "delivery",
msg)) {
slowDeliveryDetected = true;
}
}
}
msg.recycleUnchecked();
}
}可以看出来，这里先是获取了一个当前的looper对象，然后获取这个looper对应的messagequeue，然后就行入了一个死循环中，这个死循环的目的是“不断”的从messagequeue中调用next方法，获取到其中的message，然后调用message的target（handler）的dispatchMessage方法。到这里其实就已经完成一次message的传递了。
这里我们还要关注一下Message msg = queue.next() 这行代码。我们进入到源码去看一下
Message next() {
final long ptr = mPtr;
if (ptr == 0) {
return null;
}
int pendingIdleHandlerCount = -1; // -1 only during first iteration
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;
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 {
mMessages = msg.next;
}
msg.next = null;
msg.markInUse();
return msg;
}
} else {
// No more messages.
nextPollTimeoutMillis = -1;
}
if (mQuitting) {
dispose();
return null;
}
if (pendingIdleHandlerCount < 0
&& (mMessages == null || now < mMessages.when)) {
pendingIdleHandlerCount = mIdleHandlers.size();
}
if (pendingIdleHandlerCount <= 0) {
// No idle handlers to run. Loop and wait some more.
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; // release the reference to the handler
boolean keep = false;
try {
keep = idler.queueIdle();
} catch (Throwable t) {
}
if (!keep) {
synchronized (this) {
mIdleHandlers.remove(idler);
}
}
}
pendingIdleHandlerCount = 0;
nextPollTimeoutMillis = 0;
}
}这个方法主要的目的就是获取下一个待处理的message。第一眼看上去这里面也有个死循环，但是这里面有个return，也是这个return输出了message退出了这个循环。
除此之外，我们还要关注一个地方那就是 nativePollOnce(ptr, nextPollTimeoutMillis)，这个是一个nativie方法，也是这个next()方法为什么会造成block（堵塞）的原因，由于本文是从java层面来讲解handler，所以这里不展开讲解。对于这个方法，我们需要知道的是他的参数的作用就是通过Native层的MessageQueue阻塞nextPollTimeoutMillis毫秒的时间
1.如果nextPollTimeoutMillis=-1，一直阻塞不会超时。
2.如果nextPollTimeoutMillis=0，不会阻塞，立即返回。
3.如果nextPollTimeoutMillis>0，最长阻塞nextPollTimeoutMillis毫秒(超时)，如果期间有程序唤醒会立即返回。
到这里我们就可以解开第二步中埋的坑了，第二步中唤醒的就是这里的方法。
那么到这里第三步也就解析完了。
最后我们做个总结：
首先，我们在创建一个新的handler的，在我们大部分的时候我们都是在UI线程完成的，所以系统在初始化的时候，就帮我们完成了对应主线程Looper的prepare，以及loop这两个步骤。
第二步，在调用sendmessage之后，系统会把我们创建的message，根据所需要展示的时间（when）存入一个单链表messagequeue中，存放完之后，再根据我们刚存入的message，决定是否唤醒我们Looper。
最后一步，Looper会从messagequeue取出最新的一条message，若果没有的话，就会暂时通过native的方法堵塞Looper，这样可以防止多余的资源损耗。若有message的话，就会调用message的target来调用dispatchMessage方法，从而完成了一次完整的消息传送。
扫一扫
2118
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
