消息机制Handler及相关源码分析

一、Handler

1、工作原理：

Handler发送消息是往消息队列MessageQueue中插入一条消息，轮询器Looper会调用loop方法进行轮询，获取到消息后将该消息交给Handler处理。

2、发送消息（调用send和post的相关方法发送消息）

调用sendMessage，然后调用sendMessageDelayed，又调用了sendMessageAtTime。调用post方法，最终也是调用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);}

会调用MessageQueue的enqueueMessage方法将消息放到消息队列中。Looper发现新消息，会处理。
3、接收消息

#Handler

public void dispatchMessage(Message msg) {    if (msg.callback != null) {        handleCallback(msg);//是一个Runnable对象，实际是Handler的post传递的Runnable参数    } else {        if (mCallback != null) {            if (mCallback.handleMessage(msg)) {                return;            }        }        handleMessage(msg);    }}

4、Handler实例化

通过特定的Looper来构造Handler

public Handler(Looper looper) {    this(looper, null, false);}

二、Looper：不停的从消息队列MessageQueue中查看是否有新消息。

1、创建Looper。每个线程最多只能有一个Looper对象。

（1）Looper.prepare();  

#Looper

public static void prepare() {    prepare(true);}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));}

private Looper(boolean quitAllowed) {    mQueue = new MessageQueue(quitAllowed);//创建一个MessageQueue.    mThread = Thread.currentThread();}

（2）Looper.prepareMainLooper:主线程创建Looper，本质也是通过prepare方法创建

2、获取Looper

（1）Looper.getMainLooper 获取主线程的Looper

（2）Looper.myLooper()获取当前线程的Looper实例

3、退出Looper

#Looper

（1）直接退出Looper

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

（2）设置一个退出标识，将消息队列的已有消息处理完毕才能安全退出。

public void quitSafely() {    mQueue.quit(true);}

会调用MessageQueue的quit方法通知消息队列退出，MessageQueue的next方法返回null。

退出后Handler发送的消息会失败。在子线程中创建Looper，在所有消息完成后调用quit方法来终止消息循环。
4、进行轮询

Looper.looper

public static void loop() {    .....    //无限循环    for (;;) {        //调用MessageQueue的next方法取值        Message msg = queue.next();        if (msg == null) {            //木有消息了就跳出循环            return;        }        // This must be in a local variable, in case a UI event sets the logger        Printer logging = me.mLogging;        if (logging != null) {            logging.println(">>>>> Dispatching to " + msg.target + " " +                    msg.callback + ": " + msg.what);        }        //msg.target指发送消息的Handler，交给Handler的dispatchMessage方法        msg.target.dispatchMessage(msg);        .....    }}

5、数据存取

static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

通过ThreadLocal可以实现Looper在线程的数据存取。
原理：Looper作用域是线程，不用线程有不用的Looper。而ThreadLocal是一个线程内部的数据存储类。可在指定线程存储数据，其他线程无法获取。

（1）ThreadLocal使用：

ThreadLocal<Boolean> mThreadLocal = new ThreadLocal<>();public void test() {    Log.e(TAG, "mainThread:" + mThreadLocal.get());  //主线程 结果是false    new Thread() {        @Override        public void run() {            super.run();            mThreadLocal.set(false);            Log.e(TAG, "thread1:" + mThreadLocal.get());  //线程1 结果是false        }    }.start();    new Thread() {        @Override        public void run() {            super.run();            mThreadLocal.set(true);            Log.e(TAG, "thread2:" + mThreadLocal.get());  //线程2 结果是true        }    }.start();}

（2）ThreadLocal的set方法：

public void set(T value) {    Thread currentThread = Thread.currentThread();//获取当前线程    Values values = values(currentThread);  //Value的类型是ThreadLocal.Value    if (values == null) {    //value为null，进行初始化        values = initializeValues(currentThread);    }    values.put(this, value); //调用value的put方法存值}//内部存在obect类型的数组static class Values {    private Object[] table;}

（3）ThreadLocal的get方法：

public T get() {    // Optimized for the fast path.    Thread currentThread = Thread.currentThread();    Values values = values(currentThread); //获取当前线程value对象    if (values != null) {        Object[] table = values.table;     //取出value的table数组        int index = hash & values.mask;        if (this.reference == table[index]) {            return (T) table[index + 1];   //table的下一个位置存得值就是ThreadLocal的值        }    } else {        values = initializeValues(currentThread); //初始化    }    return (T) values.getAfterMiss(this);}

set和get都是操作的当前线程的value对象的table数组。

三、MessageQueue：

内部以单链表的形式存储数据，包含两个操作，插入enqueueMessage方法和读取next方法。

next是一个无限循环的方法，如果没消息就一直堵塞。如果有新消息到来，从消息队列中取出一条数据，并将其在队列中移除。

四、主线程的消息循环

1、主线程的入口是ActivityThread的main方法

public static void main(String[] args) {    .....    //创建主线程的Looper和MessageQueue    Looper.prepareMainLooper();    ActivityThread thread = new ActivityThread();    thread.attach(false);    //获取handler    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进行轮询    Looper.loop();    throw new RuntimeException("Main thread loop unexpectedly exited");}

返回的Handler是ActivityThread.H。包含了四大组件启动和停止的过程。

private class H extends Handler {}

主线程的消息循环模型：

（1）ActivityThread通过内部类ApplicationThread和ActivityManagerService进行进程间通信

（2）AMS会回调ApplicationThread的Binder方法

（3）ApplicationThread向H发送消息

（4）ApplicationThread将通过H将逻辑切换到ActivityThread中执行（主线程执行）

注意：

• 一个Looper只能对应了一个MessageQueue。
• 一个线程中只有一个Looper实例，一个MessageQueue实例，
• 可以有多个Handler实例。

参考：Android开发艺术探索