Handler消息机制(深入源码分析)

什么是Handle，有什么用?

Handle主要处理线程间通信。在Android的应用启动时，会创建一个主线程，主线程会创建一个
消息队列来处理各种消息。当你创建子线程时，你可以在你的子线程中拿到父线程中
创建的Handler 对象，就可以通过该对象向父线程的消息队列发送消息了。由于Android
要求在UI线程中更新界面，因此，可以通过该方法在其它线程中更新界面。

Handle的消息机制主要涉及三个核心类和一个数据结构:

Message ： 消息

Message Queue：消息队列 一个数据接口。存放所有的Message，它被封装在Looper中

Looper ： 一个线程可以产生一个Looper对象，由它通过死循环来管理此线程里的Message Queue

Handler ： 构造Handler对象来与Looper沟通，以便push 新消息到 Message Queue里，或者
接收Looper从Message Queue 里所送来的消息。

如上三个核心类的创建与执行流程：

创建的Message的方法:

Message.obtain()//推荐这样来从消息池中获得空消息对象，而不是使用 new 。

    Message msg = new Message()

Handler

new Handler(){

        handlerMessage(Message msg){
            // 处理消息
        }
    }

Handler的构造方法：

    public Handler() {
                ...
                // 获取looper
                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 = null;
            }

主线程设置Looper，在ActivityThread类里面:
每一个线程里可含有一个 Looper 对象以及一个 Message Queue 数据结构。每个handler 对应一个线程 thread，在子线程中 handler 发送的消息会进入到 Message Queue当中去，由 looper 再来分发给 Handler 处理。

public static final void main(String[] args) {
                ....
                // 1.主线程创建Looper 
                Looper.prepareMainLooper();
                if (sMainThreadHandler == null) {
                    sMainThreadHandler = new Handler();
                }

                ActivityThread thread = new ActivityThread();
                thread.attach(false);

                if (false) {
                    Looper.myLooper().setMessageLogging(new
                            LogPrinter(Log.DEBUG, "ActivityThread"));
                }

                Looper.loop();

Looper：

    public static final void prepare() {
            if (sThreadLocal.get() != null) {
                throw new RuntimeException("Only one Looper may be created per thread");
            }
            // 3、在主线程中设置Looper， new Looper()里面创建了一个MessageQueue
            sThreadLocal.set(new Looper());//通过ThreadLocal保证了线程安全
}
                     //在Activity中调用的prepareMainLooper
public static final void prepareMainLooper() {
                // 2、调用prepare
                prepare();
                setMainLooper(myLooper());
                if (Process.supportsProcesses()) {
                    myLooper().mQueue.mQuitAllowed = false;
                }
            }

主线程调用Looper.loop()方法,主线程就会阻塞，是一个死循环，使用管道（Pipe），是Linux中的一种进程间通信方式，使用了特殊的文件，有两个文件描述符（一个是读取，一个是写入）

应用场景；主进程拿着读取描述符等待读取，没有内容时就阻塞，另一个进程拿写入描述符去写内容，唤醒主进程，主进程拿着读取描述符读取到内容，继续执行。

Handler应用场景：Handler在主线程中创建，Looper会在死循环里等待取消息，1、没取到，就阻塞，2、一旦被子线程唤醒，取到消息，就把Message交给Handler处理。子线程用Handler去发送消息，拿写入描述符去写消息，唤醒主线程。

loop()代码如下:

         public static final void loop() {
                ...
                while (true) {
                    // 取消息，如果没有消息，就阻塞
                    Message msg = queue.next(); // might block
                    ...
                //msg.target是一个Handler
                    msg.target.dispatchMessage(msg);
                    ...
                }
            }

Handler发送消息代码

 public boolean sendMessageAtTime(Message msg, long uptimeMillis)
        {
                ....
// 把Message的target置为当前发送的Handler，以便Looper取到message后根据target把message分发给正确的Handler
//因为Message与Handler是多对一。通过Message的target这个变量保证了不会对应错
                    msg.target = this;
                    // 往队列里面添加Message
                    sent = queue.enqueueMessage(msg, uptimeMillis);
                ....
 }

MessageQueue.enqueueMessage 代码

final boolean enqueueMessage(Message msg, long when) {
        ...
            Message p = mMessages;
            if (p == null || when == 0 || when < p.when) {
                // 当前发送的message需要马上被处理调，needWake唤醒状态置true
                msg.next = p;
                mMessages = msg;
                needWake = mBlocked; // new head, might need to wake up
            } else {
                // 当前发送的message被排队到其他message的后面，needWake唤醒状态置false
                Message prev = null;
                while (p != null && p.when <= when) {
                    prev = p;
                    p = p.next;
                }
                msg.next = prev.next;
                prev.next = msg;
                needWake = false; // still waiting on head, no need to wake up
            }
        }
        // 是否唤醒主线程
        if (needWake) {
            nativeWake(mPtr);
        }
        return true;

Handler.dispatchMessage方法

    public void dispatchMessage(Message msg) {
                if (msg.callback != null) {
                    handleCallback(msg);
                } else {
                    if (mCallback != null) {
                        if (mCallback.handleMessage(msg)) {
                            return;
                        }
                    }
                    // 把Message交给Handler处理
                    handleMessage(msg);
                }
            }