Android消息队列源码解析（Handler、Looper、Message、MessageQueue）

本文链接：https://blog.csdn.net/dapangzao/article/details/77650046

前言

说到Android的消息队列，大家或多或少都能说个大概，原理啥的在网上一搜就是一大堆。记得之前刚毕业有次面试的时候被问到这个问题，当时我也只是从网上了解到原理，就按照记忆说了。后来面试官又补充问了一句，Handler有什么用，我说，可以在别的线程更新主线程UI。他问还有么，我一脸懵逼。好了，闲扯到此，本文带大家从源码角度看看Handler机制的实现与到底有什么用。

一、Handler的简单使用

直接上代码：

Handler handler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
        super.handleMessage(msg);
        switch (msg.what) {
            case 0x1:
                // 更新UI
                break;
        }
    }
};
Message message = handler.obtainMessage();
message.what = 0x1;
handler.sendMessage(handler.obtainMessage());

子线程通知UI更新，这是最基本的使用，相信大家刚学Android的时候都是这么玩的。还有一种：

handler.postDelayed(new Runnable() {
    @Override
    public void run() {
       // to do something 
    }
}, 3000);

这个方法是延迟3s后再执行操作。其实，不严格来说，在IPC中还有一种Messager机制，也是使用Handler的方式实现，有兴趣大家可以了解一下。但是其本质还是上述的方法，只是基于AIDL实现了跨进程通信。

二、源码解析

1. Handler

先来看看Handler的类注释。

Handler用于发送和处理与该线程（创建Handler对象的线程）的MessageQueue相关联的Message与Runnable对象。Handler对象在创建时与创建它的线程及该线程的MessageQueue关联。Handler可以发送Message到该MessageQueue队列并在出队列时处理任务。

Handler有两个用途：1）调度message和runnable到以后特定时间执行；2）在不同的线程将Message入队列到创建它的线程执行。

通过一系列的post与sendMessage方法来调度任务。post方法将Runnable对象加入队列，sendMessage方法将Message对象加入队列，之后通过handler的handleMessage方法来处理，因此要重写Handler的该方法。可以指定Message在消息队列准备好处理它时立即处理，也可以指定延迟或特定时间时处理。

首先来看一下Handler如何与线程的MessageQueue关联，其构造方法如下：

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

        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

mLooper = Looper.myLooper()；首先获取到该线程的looper对象，如果没有则说明还有初始化looper，会抛出异常。之后则将looper的mQueue赋给handler的mQueue引用。完成handler与MessageQueue的绑定。

post与sendMessage发送消息
在源码中，可以看到，4个post方法与5个sendMessage方法最终都调用了sendMessageAtTime(Message msg, long uptimeMillis)方法。只有postAtFrontOfQueue(Runnable r)方法调用了sendMessageAtFrontOfQueue(Message msg)。而两者最终都调用了enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis)方法。

所有的5个post方法都通过getPostMessage(Runnable r)将Runable对象封装成Message对象。该方法如下：

private static Message getPostMessage(Runnable r) {
    Message m = Message.obtain();
    m.callback = r;
    return m;
}

该方法通过Message.obtain()获取Message实例，将Runable对象置于message的callback引用下。
最后看一下这个enqueueMessage(Message msg, long when)方法。

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
    msg.target = this;
    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis);
}

可以看到首先就将Handler实例的引用放到了Message的target中，方便在处理时取出handler进行处理，但是这样就会造成另一个问题，就是内存泄漏。一般我们会在handler中更新UI控件，但是这些控件会引用创建它们的Activity，因此像上述这样做法就会导致Activity实例无法释放回收内存，一般这种情况，会采用对Activity使用弱引用的方法，这个下文再提一下实现。

最后又调用了MessageQueue的enqueueMessage方法将message加入队列。

dispatchMessage分发处理消息

public void dispatchMessage(Message msg) {
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        handleMessage(msg);
    }
}

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

/**
 * Subclasses must implement this to receive messages.
 */
public void handleMessage(Message msg) {
}

这个方法是Looper调用来处理Message用的，这个Looper我们后面再说，先看这个方法实现。首先判断Message中的callback引用是否为空，如果不为空，则直接执行callback。这个callback就是上面post方法传递来的参数。而如果不存在callback，就在下面执行handleMessage(msg)方法，这个方法就很熟悉了，我们定义Handler都要重写handleMessage(Message message)方法，该方法实现为空，注释上说明了，子类要实现该方法来接收Message。当然，handleMessage之前还有个Handler的Callback非空判断，这是在定义Handler时传来的参数，如果该Callback执行结果为true，则所有该Handler的sendMessage发来的Message都不会被执行，而是被该Callback拦截掉。

2.MessageQueue与Message

MessageQueue

MessageQueue类是持有由Looper分发的message列表的类，Message不是直接添加到MessageQueue中，而是通过Handler对象实现添加。可以通过Looper的myQueue()方法获取到当前线程的MessageQueue。该类使用了很多native方法，涉及到底层实现。（尴尬，C和C++都还给老师了）

Message

Message类则定义了一个包含描述与任意数据对象的消息类，可以发送给Handler。包含两个额外的int和一个Object对象引用，这俩并不是一定要分配对象。当然，还有what等变量。我们一般会在waht中放辨识消息的标志，在obj中放要传递的消息内容。

尽管Message构造方法是public的，但是还是建议使用Message.obtain()方法。
看一下实现：

public static Message obtain() {
    synchronized (sPoolSync) {
        if (sPool != null) {
            Message m = sPool;
            sPool = m.next;
            m.next = null;
            m.flags = 0; // clear in-use flag
            sPoolSize--;
            return m;
        }
    }
    return new Message();
}

使用同步代码，如果当前的sPoll不为空，则取出当前的Message对象，sPoll指向Message的next引用。否则会new一个新Message对象出来。

还有就是recycleUnchecked()：

void recycleUnchecked() {
    // Mark the message as in use while it remains in the recycled object pool.
    // Clear out all other details.
    flags = FLAG_IN_USE;
    what = 0;
    arg1 = 0;
    arg2 = 0;
    obj = null;
    replyTo = null;
    sendingUid = -1;
    when = 0;
    target = null;
    callback = null;
    data = null;

    synchronized (sPoolSync) {
        if (sPoolSize < MAX_POOL_SIZE) {
            next = sPool;
            sPool = this;
            sPoolSize++;
        }
    }
}

代码很简单，将Message对象的各个变量进行数据清空，之后则将该Message添加到sPool中。

通过创建与回收的代码可以看到，Message采用链表结构进行存储与复用。正如上文提到的使用享元模式可以循环利用这些对象，实现Message对象的循环使用，避免重复创建。

3. Looper

最后来看看Looper。

相信大家在初学时，肯定也干过在子线程创建Handler抛出异常的事。其实很简单，看看代码就晓得了。

首先看一下注释。
为线程循环执行message的类。线程默认没有looper关联，要使用prepare方法创建并调用loop方法来处理message。

主要的方法：

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

首先构造方法中创建了MessageQueue，然后获取到当前线程的引用，但是该方法是private权限的，因此只有内部可以访问，这里就要涉及到上面说的prepare方法了。

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并绑定到当前线程中。

而通过myLooper()与myQueue()方法则可以获取到当前线程绑定的looper以及该looper绑定的MessageQueue。

loop

Looper类最重要的方法莫过于loop()方法，用于循环分发处理Message。

public static void loop() {
    final Looper me = myLooper();
    if (me == null) {
        throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
    }
    final MessageQueue queue = me.mQueue;

    // Make sure the identity of this thread is that of the local process,
    // and keep track of what that identity token actually is.
    Binder.clearCallingIdentity();
    final long ident = Binder.clearCallingIdentity();

    for (;;) {
        Message msg = queue.next(); // might block
        if (msg == null) {
            // No message indicates that the message queue is quitting.
            return;
        }

        // This must be in a local variable, in case a UI event sets the logger
        final Printer logging = me.mLogging;
        if (logging != null) {
            logging.println(">>>>> Dispatching to " + msg.target + " " +
                    msg.callback + ": " + msg.what);
        }

        final long traceTag = me.mTraceTag;
        if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
            Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
        }
        try {
            msg.target.dispatchMessage(msg);
        } finally {
            if (traceTag != 0) {
                Trace.traceEnd(traceTag);
            }
        }

        if (logging != null) {
            logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
        }

        // Make sure that during the course of dispatching the
        // identity of the thread wasn't corrupted.
        final long newIdent = Binder.clearCallingIdentity();
        if (ident != newIdent) {
           Log.wtf(TAG, "Thread identity changed from 0x"
                    + Long.toHexString(ident) + " to 0x"
                    + Long.toHexString(newIdent) + " while dispatching to "
                    + msg.target.getClass().getName() + " "
                    + msg.callback + " what=" + msg.what);
        }

        msg.recycleUnchecked();
    }
}

分析一下代码：

首先获取当前线程的Looper，如果不存在则抛出异常。然后获取到线程绑定的MessageQueue对象。之后开始了无限循环从消息队列中取出消息加以处理。

取出消息的时候Message msg = queue.next()方法，可能会发生阻塞。如果没有message则消息队列退出。之后则调用msg.target.dispatchMessage(msg);来进行处理Message。而我们在分析Handler时发现，target变量中存放的就是Handler对象。Handler的dispatchMessage方法上面也分析过了，这样就实现了消息的处理。在最后调用msg.recycleUnchecked()方法对Message进行数据清理复用。

这四个类就分析到这里。

三、问题与总结

1. 主线程为何不要Looper.preapre()与Looper.loop()

这个，相信很多人都是知道的，提一下，就是在ActivityThread的main方法中（管理应用程序主线程的执行，相当于普通java程序的main入口）执行了prepare与loop。如下：

Looper.prepareMainLooper();
...
Looper.loop();

2. 使用内部类的形式定义Handler造成的问题

如果大家够严谨的话，会发现如果使用内部类形式定义一个Handler，编译器会发出警告，就是内存泄漏的问题。如图：

内存泄漏警告

这里大概就是说，如果内部类使用外部类的引用，会造成内存泄漏，解决方法有：使用静态内部类（这样引用到的外部类还是得弱引用）；使用外部类，且使用到的Activity引用为弱引用；使用内部类但对所有引用到的外部类成员使用弱引用。
具体解决代码如下：

private static class MyHandler extends Handler {
    WeakReference<MainActivity> mActivityWeakReference;
    public MyHandler(Activity activity) {
        mActivityWeakReference = new WeakReference<>(activity);
    }
    @Override
    public void handleMessage(Message msg) {
        MainActivity activity = mActivityWeakReference.get();
        if (activity != null) {
            switch (msg.what) {
                case 0x1:
                    // 更新UI
                    break;
            }
        }
    }
};

弱引用的特点，就是相对于强引用，当GC回收时，如果仅有一个弱引用指向该对象，则会回收该对象。这样当activity被关闭之后，就可以及时回收，而不用担心内存泄漏。

3.总结

总结一下Android消息队列的实现原理。首先在新线程中（包括主线程，系统做好了）调用Looper.preapre()，初始化线程的Looper与MessageQueue，之后调用Looper.loop()循环从MessageQueue中取出Message并调用绑定的Handler执行dispatchMessage方法分发处理。而使用Handler把Message发送到MessageQueue队列中，同时也会把Handler绑定到Message中。

从中我们可以收获以下知识：