深入理解Android消息机制

二、Android的消息机制
Android的消息机制主要说的是Handler的运行机制，Handler的运行需要MessageQueue和Looper，MessageQueue就是消息队列，它是采用单链表的数据结构来存储消息列表。而Looper会不断的查看MessageQueue中是否有消息，当有消息的时候就取出来。Hanlder在创建的时候会采用当前线程的Looper来构造消息循环系统，但是默认的线程是没有Looper的，比如我们在子线程创建一个Hanlder（这里只是便于演示所以不采用线程池了，建议标准开发中使用线程池）

/**
 * 子线程使用Hanlder测试方法
 */
private void ThreadHandlerTest() {
    new Thread(new Runnable() {
        @Override
        public void run() {
            Handler handler = new Handler();
        }
    }).start();
}

运行结果报错如下：

java.lang.RuntimeException: Can't create handler inside thread Thread[Thread-2,5,main] that has not called Looper.prepare()
at android.os.Handler.<init>(Handler.java:206)
at android.os.Handler.<init>(Handler.java:119)
at lonbon.com.hanlderlooperdemo.MainActivity$1.run(MainActivity.java:24)
at java.lang.Thread.run(Thread.java:764)

这只因为默认的线程中没有Looper，所以我们要为当前线程创建Looper对象：

Looper.prepare();
Handler handler = new Handler();
Looper.loop();

我们通过Looper.prepare()方法创建Looper对象，.loop()方法开启消息循环。关于looper详细的下面讲解。

那么我们可能有疑问了，我们在主线程中使用Handler的时候没有创建looper对象也可以正常使用，那是因为默认的UI线程创建的时候默认创建了looper对象。

创建完Handler之后，通过handler的send或者post方法发送消息，这个消息会被存储到消息队列，Looper发现消息队列中有新的消息便会处理这个消息，然后handlermessage方法或者Runable方法会被调用，大致过程如图所示。

在这里插入图片描述
三、ThreadLocal
ThreadLocal是Looper中的特殊概念，用来在当前线程中存储数据，我们获取当前线程的Looper也是通过ThreadLocal操作的，当然，日常开发中我们能使用的ThreadLocal的地方并不多。比如我们在两个不同线程中进行如下操作：

首先我们声明一个String类型的ThreadLocal变量，创建两个线程分别使用set方法赋值，然后打印。

 private ThreadLocal<String> threadLocal = new ThreadLocal<>();
 

/**
 * 测试线程1
 */
private void ThreadTest1() {
    new Thread(new Runnable() {
        @Override
        public void run() {
            threadLocal.set("BigYellow");
            Log.d(TAG,threadLocal.get());
        }
    }).start();
}

/**
 * 测试线程2
 */
private void ThreadTest2() {
    new Thread(new Runnable() {
        @Override
        public void run() {
            threadLocal.set("大黄");
            Log.d(TAG,threadLocal.get());
        }
    }).start();
}

运行打印，日志如下：

02-12 10:21:37.961 11719-12135/? D/TAG: BigYellow
02-12 10:21:37.966 11719-12136/? D/TAG: 大黄

我们可以看到取出的分别是各自线程对应的值，如果我们在主线程中呢？显然是null因为我们没有在主线程中存值。

接下来我们从源码的角度来分析ThreadLocal的存取值过程，首先我们看set方法。

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

首先通过getMap方法获取当前线程的ThreadLocalMap，如果map不为空就通过map的set方法将值存储，如果为空则创建map，

我们来看下ThreadLocalMap，ThreadLocalMap是一个存储当前线程数据的Map集合，set方法源码如下所示：

private void set(ThreadLocal<?> key, Object value) {

    // We don't use a fast path as with get() because it is at
    // least as common to use set() to create new entries as
    // it is to replace existing ones, in which case, a fast
    // path would fail more often than not.

    Entry[] tab = table;
    int len = tab.length;
    int i = key.threadLocalHashCode & (len-1);

    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        ThreadLocal<?> k = e.get();

        if (k == key) {
            e.value = value;
            return;
        }

        if (k == null) {
            replaceStaleEntry(key, value, i);
            return;
        }
    }

    tab[i] = new Entry(key, value);
    int sz = ++size;
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

首先定义了一个Entry类型的数组，我们主要来看for循环中的操作，for循环主要做的就是为插入值得位置找到合适的位置，通过不断到table数组中去寻找，直到存放的entry为null

if (k == key) {
    e.value = value;
    return;
}

如果key的值相同说明该线程曾经设置过Threadlocal，直接赋值即可。

if (k == null) {
    replaceStaleEntry(key, value, i);
    return;
}

Entry继承的是WeakReference，这是弱引用带来的坑

所以要判断是否为null，如果为null就进行置换操作，即

replaceStaleEntry(key, value, i);

private void replaceStaleEntry(ThreadLocal<?> key, Object value,
                               int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;
    Entry e;

    // Back up to check for prior stale entry in current run.
    // We clean out whole runs at a time to avoid continual
    // incremental rehashing due to garbage collector freeing
    // up refs in bunches (i.e., whenever the collector runs).
    int slotToExpunge = staleSlot;
    for (int i = prevIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = prevIndex(i, len))
        if (e.get() == null)
            slotToExpunge = i;

    // Find either the key or trailing null slot of run, whichever
    // occurs first
    for (int i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();

        // If we find key, then we need to swap it
        // with the stale entry to maintain hash table order.
        // The newly stale slot, or any other stale slot
        // encountered above it, can then be sent to expungeStaleEntry
        // to remove or rehash all of the other entries in run.
        if (k == key) {
            e.value = value;

            tab[i] = tab[staleSlot];
            tab[staleSlot] = e;

            // Start expunge at preceding stale entry if it exists
            if (slotToExpunge == staleSlot)
                slotToExpunge = i;
            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
            return;
        }

        // If we didn't find stale entry on backward scan, the
        // first stale entry seen while scanning for key is the
        // first still present in the run.
        if (k == null && slotToExpunge == staleSlot)
            slotToExpunge = i;
    }

    // If key not found, put new entry in stale slot
    tab[staleSlot].value = null;
    tab[staleSlot] = new Entry(key, value);

    // If there are any other stale entries in run, expunge them
    if (slotToExpunge != staleSlot)
        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}

当table数组中存储的ThreadLocal对应的值还在但是key不存在了，就认为Entry过期了，

int slotToExpunge = staleSlot;
for (int i = prevIndex(staleSlot, len);
     (e = tab[i]) != null;
     i = prevIndex(i, len))
    if (e.get() == null)
        slotToExpunge = i;

上述代码检查脏数据，清理整个table，否则会因为GC问题导致很严重的后果。

if (k == key) {
    e.value = value;

    tab[i] = tab[staleSlot];
    tab[staleSlot] = e;

    // Start expunge at preceding stale entry if it exists
    if (slotToExpunge == staleSlot)
        slotToExpunge = i;
    cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
    return;
}

如果找到key了我们需要进行替换，将过期数据进行删除刷新。源代码中注释的很清楚了，这里就不一一解释了。

个人感觉和之前早期版本（6.0之前）的set方法变化很大。

我们接下来来看ThreadLocal的get方法，首先同样的获取当前线程的ThreadLocalMap，获取map的entry对象，如果不为空的话就从中取值即可。如果map为空就回到setInitialValue初始化方法.

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}

四、Looper
Looper我们上面说了是用来构建消息循环系统，我们通过ThreadLocal来获取当前线程的Looper对象.我们上面也说到了如何在子线程中创建looper，通过Looper的prepare方法为当前线程创建一个looper，通过loop方法开启消息循环。在主线程中创建Looper是通过

Looper.prepareMainLooper();

方法，因为UI线程的Looper比较特殊是默认创建好的，所以我们可以通过下列代码来获取主线程的looper

Looper.getMainLooper();

我们可以开启looper肯定也可以关闭looper，关闭looper有这个方法，一个是

getMainLooper().quit();

public void quit() {
    mQueue.quit(false);
}

quit方法会直接退出looper，另一种方法是

getMainLooper().quitSafely();

和quit方法不同的是quitSafely方法调用后在消息队列中的消息处理完成之后在退出，就像方法名一样是安全退出。所以如果我们在子线程中手动创建了looper，记得在执行完线程后调用退出方法，否则子线程会一直处于等待状态，影响性能。

接下来我们看looper是如何通过loop方法开启消息循环的，loop方法源码如下所示：

/**
 * Run the message queue in this thread. Be sure to call
 * {@link #quit()} to end the loop.
 */
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 slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;

        final long traceTag = me.mTraceTag;
        if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
            Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
        }
        final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
        final long end;
        try {
            msg.target.dispatchMessage(msg);
            end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
        } finally {
            if (traceTag != 0) {
                Trace.traceEnd(traceTag);
            }
        }
        if (slowDispatchThresholdMs > 0) {
            final long time = end - start;
            if (time > slowDispatchThresholdMs) {
                Slog.w(TAG, "Dispatch took " + time + "ms on "
                        + Thread.currentThread().getName() + ", h=" +
                        msg.target + " cb=" + msg.callback + " msg=" + msg.what);
            }
        }

        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会不断的调用

queue.next()

方法从消息队列中取出消息，如果为空就一直等待，如果有消息就调用

msg.target.dispatchMessage(msg);

方法处理msg.target就是发送这条消息的Handler对象，而handler的dispatchMessage方法又是在创建Handler所在的Looper执行的，所以这样就将消息交给指定的线程去处理了。

五、消息队列MessageQueue与Handler
消息队列MessageQueue主要有插入和读取两个操作，读取成功后也就相当于删除。

插入方法对应的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;
}

我们上面也说了消息队列其实是一个单链表，所以就相当于单链表的插入操作。读取方法是next方法，读取后将消息移除，这里就不作过多解释了。

而我们日常开发中最常用的就是创建Hanlder的匿名内部类方式（这种方式记得处理内存泄漏），然后通过hanlder.send方法发送消息，而send方法最终又会调用sendMessageAtTime方法，源码如下：

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

我们看最终返回值就可以看到其实调用handler的send方法就是调用enqueueMessage方法往消息队列中插入了一条消息，然后不断循环的looper进去取出又交给handler处理，这样就构成了Android的消息机制。

上文源码基于Android8.0，如有纰漏欢迎指出探讨。