Android读书笔记（10）—— Android的消息机制

一、Android的消息机制分析

出于性能优化的考虑，Android中UI的操作是线程不安全的。所以，Android规定：只有UI线程才能修改UI组件。
这样会导致新启动的线程无法修改UI，此时需要Handler消息机制。

1、ThreadLocal<T>的工作原理

ThreadLocal是一个线程内部的数据存储类，通过它可以在指定线程中存储数据，数据存储后，只有在指定线程中可以获取到存储的数据，对于其他线程来说无法获得数据。

1.1、使用场景

当某些数据是以线程为作用域并且不同线程具有不同的数据副本的时候，就可以考虑采用ThreadLocal。比如对于Handler来说，它需要获取当前线程的Looper，而Looper的作用域就是线程并且不同的线程具有不同的Looper，通过ThreadLocal可以轻松实现线程中的存取。
复杂逻辑下的对象传递。比如监听器的传递，有时候一个线程中的任务过于复杂，表现为函数调用栈比较深以及代码入口的多样性，而这时我们又希望监听器能够贯穿整个线程的执行过程。此时可以让监听器作为线程内的全局对象而存在，在线程内部只要通过get方法就可以获取到监听器。
如果不采用ThreadLocal，只能采用函数参数的形式在栈中传递或作为静态变量供线程访问。第一种方式在调用栈很深时，看起来设计很糟糕，第二种方式不具有扩展性，比如同时N个线程并发执行。

1.2、常用方法

set(T value) 设置到当前线程内部的ThreadLocal.ThreadLocalMap对象中的Entry[]数组的某个Entry中。Entry类似于一个Map，key是ThreadLocal对象，value是具体的值T，重复设置会覆盖。
get() T 循环当前线程内部的ThreadLocal.ThreadLocalMap对象中的Entry[]数组，取出当前对象的key对应的值

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);//获取当前线程的ThreadLocal.ThreadLocalMap对象
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

在不同线程访问同一个ThreadLocal对象，获得的值却是不同的。

2、MessageQueue的工作原理

用于存放Handler发送过来的消息。主要包含两个操作：插入和读取。读取操作本身会伴随着删除操作。内部通过一个单链表的数据结构来维护消息列表，因为其在插入和删除上的性能较高。插入和读取对应的方法分别是：enqueueMessage和next方法。

2.1、Message

线程之间传递的消息，可以携带少量数据

1）属性

what 用户自定义的消息码
arg1 携带整型数据
arg2 携带整型数据
obj 携带对象
replyTo Messenger类型

2）方法

sendToTarget()
obtain() Message 从消息池中获取一个消息对象。不建议使用new Message()构造。
obtain(Message orign) Message 拷贝一个Message对象
obtain(Handler h, int what) Message h：指定由谁处理，sendToTarget()就是发给他。what：指定what属性。本质还是调用Handler.sendMessage进行发送消息
obtain(Handler h, Runnable callback) Message callback：message被处理的时候调用
setData(Bundle data)
getData() Bundle

3、Looper的工作原理

每个线程的MessageQueue管家，一个线程对应一个Looper，一个MessageQueue（创建Looper的时候创建）。Looper会不停地从MessageQueue中查看是否有新消息，如果有新消息就会立即处理，否则就一直阻塞在那里。

private static void prepare(boolean quitAllowed) {
    ...
    //sThreadLocal是一个静态变量，保证了线程和Looper对象的一对一
    //存一个Looper到线程中
    sThreadLocal.set(new Looper(quitAllowed));
    ...
}

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

通过Looper.prepare()方法，创建了一个Looper，一个MessageQueue，再通过Looper.loop()开启消息循环。

public static void loop() {
    ...
    for (;;) {//无限循环
        ...
        //next()是一个无限循环方法，没有消息就阻塞，当有新消息，会返回这条消息并将其从单链表中移除
        Message msg = queue.next();
        ...
        //处理。msg.target是发送这条消息的Handler对象，这样Handler发送的消息最终又交给Handler来处理了
        msg.target.dispatchMessage(msg);
        ...
    }
}

loop()方法会调用MessageQueue#next()方法来获取新消息，next()方法是一个无限循环的方法，如果消息队列中没有消息，那么next方法会一直阻塞在这里，这也导致loop方法一直阻塞在那里。当有新消息到来时，next()方法会返回这条消息并将其从单链表中移除。如果MessageQueue的next方法返回了新消息，Looper就会处理这条消息：msg.target.dispatchMessage(msg)，这里的msg.target是发送这条消息的Handler对象，这样Handler发送的消息最终又交给Handler来处理了。

Looper提供quit()和quitSafely()来退出一个Looper，区别在于quit会直接退出Looper，而quitSafely会把消息队列中已有的消息处理完毕后才安全地退出。Looper退出后，这时候通过Handler发送的消息会失败，Handler的send方法会返回false。在子线程中，如果手动为其创建了Looper，在所有事情做完后，应该调用Looper的quit方法来终止消息循环，否则这个子线程就会一直处于等待状态；而如果退出了Looper以后，这个线程就会立刻终止，因此建议不需要的时候终止Looper。

3.1、方法

Looper.getMainLooper() Looper 返回主线程上面的Looper
Looper.myLooper() Looper 返回当前线程的Looper
prepare() 为当前线程创建Looper对象，和关联的MessageQueue（主线程无需创建，已经有了）
loop() 开始轮询，记得quit()
quit() 此时Handler.sendMessage将会返回false
quitSafely() 将已经在MessageQueue中的消息处理完，再结束
isCurrentThread() boolean 是否是当前线程的Looper
getThread() Thread 返回对应的线程

4、Handler的工作原理

Handler用于发送Message或Runnable到Handler所在线程，进行执行或处理。

Handler发送过程仅仅是向消息队列中插入了一条消息。MessageQueue的next方法就会返回这条消息给Looper，Looper拿到这条消息就开始处理，最终消息会交给Handler的dispatchMessage()来处理，这时Handler就进入了处理消息的阶段。

构造方法

...
mLooper = Looper.myLooper();//获取当前线程中保存的Looper对象，主要为了获取其中的mQueue
mQueue = mLooper.mQueue;
...

sendMessage(Message msg)

在mQueue中插入一个消息，跨线程通讯了

dispatchMessage(Message msg)

//handler处理消息的过程。由Looper#loop()调用，运行在Looper所在线程。若主动调用，就运行在调用的线程中。
public void dispatchMessage(Message msg) {
    //Message#obtain(Handler h, Runnable callback)中的callback，Handler#handleMessage(Message msg)不会被执行
    if(msg.callback != null){
        handleCallback(msg);
    } else {
        //Handler(Callback callback)中的callback（接口，只有一个方法boolean handleMessage(Message msg)）
        if (mCallback != null) {
        //返回值决定了Handler#handleMessage(Message msg)是否会被执行
            if (mCallback.handleMessage(msg)){
                return;
            }
        }
        handleMessage(msg);
    }
}

4.1、方法

构造方法：Handler()用当前线程的Looper，若当前线程没有Looper，将抛出异常
构造方法：Handler(Looper looper) 指定Looper
构造方法：Handler(Callback callback)
sendEmptyMessage(int what) boolean 发送一个仅仅包含what的Message，返回值表示是否成功插入到MessageQueue
sendEmptyMessageAtTime(int what, long uptimeMillis) uptimeMillis：指定时间发送
sendEmptyMessageDelayed(int what, long delayMillis) delayMillis：延迟n秒发送
postDelayed(Runnable r, long delayMillis) 发送Runnable对象到消息队列中，将被执行在Handler所在的线程
removeCallbacks(Runnable r)
handleMessage(Message msg) 必须要重写的方法
removeMessages(int what)
obtainMessage(int what)
sendMessage(Message msg) boolean
dispatchMessage(Message msg) 在调用此方法所在线程直接执行

4.2、使用步骤

①：调用Looper.prepare()为当前线程创建Looper对象（主线程不用创建，已经有了），然后Looper
.loop()
②：创建Handler子类的实例，重写handleMessages()方法，处理消息

4.3、HandlerThread

一个为了快速创建包含Looper的一个线程类， start()时就创建了Looper和MessageQueue对象（本质）。

构造方法： HandlerThread(String name)
getLooper() Looper
quit()
quitSafely()

用法：
mCheckMsgThread = new HandlerThread("check-message-coming");
mCheckMsgThread.start();
mCheckMsgHandler = new Handler(mCheckMsgThread.getLooper()){...}

二、主线程的消息循环

Android的主线程就是ActivityThread，主线程的入口方法为main(String[] args)，在main方法中系统会通过Looper.prepareMainLooper()来创建主线程的Looper以及MessageQueue，并通过Looper.loop()来开启主线程的消息循环。

ActivityThread通过ApplicationThread和AMS进行进程间通信，AMS以进程间通信的方式完成ActivityThread的请求后会回调ApplicationThread中的Binder方法，然后ApplicationThread会向H发送消息，H收到消息后会将ApplicationThread中的逻辑切换到ActivityTread中去执行，即切换到主线程中去执行。四大组件的启动过程基本上都是这个流程。

Looper.loop()，这里是一个死循环，如果主线程的Looper终止，则应用程序会抛出异常。那么问题来了，既然主线程卡在这里了

那Activity为什么还能启动；
点击一个按钮仍然可以响应？

问题1：startActivity的时候，会向AMS（ActivityManagerService）发一个跨进程请求（AMS运行在系统进程中），之后AMS启动对应的Activity；AMS也需要调用App中Activity的生命周期方法（不同进程不可直接调用），AMS会发送跨进程请求，然后由App的ActivityThread中的ApplicationThread会来处理，ApplicationThread会通过主线程线程的Handler将执行逻辑切换到主线程。重点来了，主线程的Handler把消息添加到了MessageQueue，Looper.loop会拿到该消息，并在主线程中执行。这就解释了为什么主线程的Looper是个死循环，而Activity还能启动，因为四大组件的生命周期都是以消息的形式通过UI线程的Handler发送，由UI线程的Looper执行的。

问题2：和问题1原理一样，点击一个按钮最终都是由系统发消息来进行的，都经过了Looper.loop()处理。问题2详细分析请看原书作者的Android中MotionEvent的来源和ViewRootImpl。