源码解析-Handler源码全面解析

116 阅读 0 评论 77 点赞

我是靠谱客的博主独特啤酒，这篇文章主要介绍源码解析-Handler源码全面解析，现在分享给大家，希望可以做个参考。

本篇文章是对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

复制代码

1
2
3
4
5
6
7
8
  Handler handler=new Handler(){
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
          
        }
    };

然后发送信息

复制代码

1
2
3
4
5
    Message message=handler.obtainMessage();
    message.what=1;
    message.arg1=i;
    message.obj="倒计时：";
    handler.sendMessage(message);

handler处理消息

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
  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方法里面找到了

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
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发送信息

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
    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这个方法里面去看看

复制代码

1
2
3
4
5
6
7
    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;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 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 这个方法里面，那这个排序的方法就可以了理解了吧

复制代码

1
2
3
4
5
6
7
8
9
10
               for (;;) {
                    prev = p;
                    p = p.next;
                    if (p == null || when < p.when) {
                        break;
                    }
                    if (needWake && p.isAsynchronous()) {
                        needWake = false;
                    }
                }

我们继续看下去

复制代码

1
2
3
            if (needWake) {
                nativeWake(mPtr);
            }

这个nativeWake的作用就是唤醒线程。至于在哪里进行唤醒，我们将在第三步揭晓。

第三步发送信息

由于这个方法不太好找，我们采用反推的反推的方式进行查看源码

首先我们根据handleMessage方法，找到了dispatchMessage()这个方法。这个两个方法都是传递消息的基础方法，这里就不讲解了

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
    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();
        }
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 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;
        }
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
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方法，从而完成了一次完整的消息传送。