Android消息机制：Handler浅析

Android的消息机制主要是指Handler的运行机制，Handler的运行需要底层的MessageQueue和Looper的支撑。Android规定访问UI只能在主线程进行，如果在子线程中访问UI，程序会抛出异常，Handler的主要作用就是将一个任务切换到某个指定线程中去执行。如在子线程获取网络数据，再更新页面UI就需要用到handler机制。
Handler主要涉及到四个类：Handler，Message，MessageQueue和Looper

MessageQueue

MessageQueue就是消息队列，但是其内部实现其实并不是队列，而是通过单链表的数据结构来维护消息列表。MessageQueue主要包含插入和读取两个操作，读取操作本身又伴随这删除操作。插入对应的方法是enqueueMessage，读取对应的方法是next。enqueueMessage就是往消息队列中插入一条消息，next是从消息队列中读取一条消息并移除它。

enqueueMessage源码如下：

boolean enqueueMessage(Message msg, long when) {
    //msg.target就是处理消息的handler
    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;
}

enqueueMessage方法返回一个布尔值，消息成功插入消息队列返回true。方法体内先判断msg.target是不是为空，msg.target其实就是处理消息的handler，handler为空自然就处理不了消息。再判断消息是不是已经被处理了，从这个判断可以得出消息不能被重复处理。接下来的操作就是单链表的插入操作，就不再赘述。如果线程是当前是堵塞状态，最后还会唤起线程。

next方法源码如下：

 Message next() {
    
    ......

    int pendingIdleHandlerCount = -1; // -1 only during first iteration
    int nextPollTimeoutMillis = 0;
    for (;;) {
        if (nextPollTimeoutMillis != 0) {
            Binder.flushPendingCommands();
        }

        //阻塞方法，主要是通过native层的epoll监听文件描述符的写入事件来实现的。
       //nextPollTimeoutMillis=-1，一直阻塞不会超时。
       //nextPollTimeoutMillis=0，不会阻塞，立即返回。
       //nextPollTimeoutMillis>0，最长阻塞nextPollTimeoutMillis毫秒(超时)，如果期间有程序唤醒会立即返回。
        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.
                //msg.target == null表示此消息为消息屏障（通过postSyncBarrier方法发送来的）
                //如果发现了一个消息屏障，会循环找出第一个异步消息（如果有异步消息的话），所有同步消息都将忽略（平常发送的一般都是同步消息)                
                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;
                    if (DEBUG) Log.v(TAG, "Returning message: " + msg);
                    msg.markInUse();
                    return msg;
                }
            } else {
                // No more messages.
                //没有消息，一直阻塞
                nextPollTimeoutMillis = -1;
            }

            // Process the quit message now that all pending messages have been handled.
            //消息队列被标记为退出状态，返回null
            if (mQuitting) {
                dispose();
                return null;
            }
               ......
        }
        ......
    }
}

next方法是一个无限循环，如果消息队列中没有消息，next方法就会一直阻塞。有新消息时，将新消息返回并移除这条消息。当消息队列被标记为退出状态时，返回null，这里先卖一个关子，这个null会在文章后面讲到。

Looper

Looper在Android消息机制扮演消息循环的角色，会不停的去MessageQueue中查看是否有新消息，如果有就立即处理，没有的话就会一直堵塞在那边。

Looper的构造函数：

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

构造函数中会新建一个MessageQueue，然后将当前的线程对象保存起来。

大家都知道创建Handler之前必须要现在线程中创建一个Looper对象，不然会报错。创建Looper对象也很简单，直接调用Looper.prepare()就可以了，创建Looper对象之后还不能实现消息循环，必须再调用loop()方法来开启消息循环。读到这里可能会有困惑，为什么在主线程创建Handler不需要我们自己创建Looper对象？答案就在ActivityThread里：

public static void main(String[] args) {
    ...
    Looper.prepareMainLooper();
    ...
    ActivityThread thread = new ActivityThread();
    thread.attach(false, startSeq);

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

从源码中可以看到在主线程启动时就已经调用了Looper.prepareMainLooper()方法，该方法是Looper提供给主线程使用的，接下来又调用了 Looper.loop()开启消息循环。这就是为什么我们在主线程创建Handler时不需要的自己创建Looper对象的原因。

再回过头来开子线程创建Handler的流程：

  thread {
        Looper.prepare()
        val handler = Handler(object : Handler.Callback {
            override fun handleMessage(msg: Message): Boolean {
                doSomething()
            }
        })
        Looper.loop()
    }

首先创建一个Looper对象，接着创建Handler，然后再开启循环。（如上为了方便用kotlin代码进行举例）
Looper提供了创建对象的方法之外还提供了quit和quitSafely方法，两个方法的唯一区别就是quit会立即退出，quitSafely会等消息队列中所有的消息处理完成之后再退出。退出之后Handler的send方法会返回false。不建议在主线程中调取quit方法，因为会立即结束主线程。当子线程中，应当在处理完所有消息之后调取quit方法来结束当前线程。
Looper中最重要的方法就是loop方法，源码如下：

public static void loop() {
    ...
    for (;;) {
        Message msg = queue.next(); // might block
        if (msg == null) {
            // No message indicates that the message queue is quitting.
            return;
        }
        ...  
        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 {
            ThreadLocalWorkSource.restore(origWorkSource);
            if (traceTag != 0) {
                Trace.traceEnd(traceTag);
            }
        }
       ...
        msg.recycleUnchecked();
    }
}

loop方法也比较好理解，他也是一个无限循环的方法。for循环中会调取MessageQueue的next方法，在之前说过next是一个阻塞方法，所以当消息队列中没有消息的时候，会一直阻塞在这里，唯一跳出循环的方式就是next方法返回了null，这里就是解答了之前在讲MessageQueue的时候为什么要返回null。当Looper调quit方法的时候，Looper就会调用MessageQueue的quit方法，然后MessageQueue的next方法就会返回null，这样loop方法才能跳出无限循环。当loop拿到了消息之后就会调用msg.target.dispatchMessage(msg)「msg.target前面讲到过就是发送这条消息的Handler」将消息交给Handler来处理了。这里需要注意的是Handler的dispatchMessage是在创建Handler时所使用的Looper中执行的，这就就成功的切换到指定线程中去执行了。

Handler

Handler的作用主要是消息发送以及接收。消息发送可以通过一系列的post方法和一系列的send方法，其实post方法到最后都是通过send方法来进行发送。

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

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

查看源码发现到最后都是通过MessageQueue的enqueueMessage将消息插入到消息队列中。之后Looper就会调用MessageQueue的next方法拿到消息，然后就进入了下一个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);
    }
}

1.先判断msg的callback是不是为null，这个callback对象其实就是handler发送消息时调用post方法所传递的Runnable参数，不为空就调用handleCallback方法处理。

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

handleCallback方法也很简单，直接执行Runnable的run方法。
2.其次检查mCallback是否为null，部位null调用mCallback的handleMessage方法，查看源码mCallBack其实是一个CallBack接口，CallBack具体如下：

public interface Callback {
    /**
     * @param msg A {@link android.os.Message Message} object
     * @return True if no further handling is desired
     */
    boolean handleMessage(@NonNull Message msg);
}

mCallBack通过构造函数传入,当你不想创建继承自Handler的派生类时，就可以通过该构造方法直接传入一个Callback参数来实现消息处理。

val handler = Handler(object :Handler.Callback{
            override fun handleMessage(msg: Message): Boolean {
                ...
           
})

3.最后调用Handler的handleMessage来处理消息

处理消息的流程图大致如下：

image.png

额外注意点：

消息机制里需要频繁创建消息对象（Message），因此消息对象需要使用享元模式来缓存，以避免重复分配 & 回收内存。具体来说，Message 使用的是有容量限制的、无头节点的单链表的对象池，创建Message的时候最好用Handler的obtainMessage来进行创建，尽量避免使用new Message()来创建造成内存抖动

2.在子线程中创建Handler时一定要先创建Looper对象，然后调用loop方法开启循环

3.尽量使用弱持有来创建Handler对象

思考：

1.一个线程可以创建几个Looper？

2.MessageQueue是否线程安全？如果是怎么保证？

3.Looper在主线程中死循环，为啥不会ANR？

4.Handler会造成内存泄漏吗？为什么？怎么解决？