Android消息机制

好多东西都忘了，看过的源码得记录一下，今天就来分析Andorid消息机制的源码。

Android消息机制主要涉及：

Handler、Looper、MessageQueue、Message、ThreadLocal

它们之间的关系如下所示：

有几个疑问：

 1. 在哪发消息？
 2. 消息发到哪里去了？
 3. 消息最后怎么被处理了？
 4. 怎么就把在子线程发的消息变换到了主线程？
 5. 上面各个类都是什么作用呢？

Android消息机制在实际开发中的应用

正式开始之前，先看一个Handler在多线程中具体使用的案例：

一个很简单的需求：点击页面上的按钮后更新TextView的内容。

public class HandlerActivity extends AppCompatActivity {

    private UpdateHandler handler;

    private TextView tv;

    static class UpdateHandler extends Handler{

        private WeakReference<HandlerActivity> mHandlerActivity;

        public UpdateHandler(HandlerActivity handlerActivity) {
            this.mHandlerActivity = new WeakReference<HandlerActivity>(handlerActivity);
        }

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            HandlerActivity handlerActivity = mHandlerActivity.get();
            if (handlerActivity != null){
                handlerActivity.tv.setText((String)msg.obj);
            }
        }
    }

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        init();
        onLoad();
    }

    private void init() {
        setContentView(R.layout.activity_handler);
        tv = (TextView) findViewById(R.id.tv);

        handler = new UpdateHandler(this);
    }

    private void onLoad(){
        new Thread(){
            @Override
            public void run() {
                super.run();

                try{
                    Thread.sleep(4000);
                }catch (Exception e){
                    e.printStackTrace();
                }

                Message msg = new Message();
                msg.what = 1;
                msg.obj = "加载完成";
                handler.sendMessage(msg);
            }
        }.start();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        handler.removeCallbacksAndMessages(null);
    }
}

在主线程创建一个Handler，然后开启一个工作线程待工作线程休眠4000毫秒后，发出一个Message然后在主线程更新TextView的内容。

消息机制源码分析

结合上面的例子，下面就挨个把这些问题搞明白：

在子线程中发出的消息，通过如下代码：

Message msg = new Message();
msg.what = 1;                 //Message标识
msg.obj = "加载完成";          //要传输的信息
handler.sendMessage(msg);

追踪sendMessage的源码：

handler.sendMessage(message);

发现经过一串的调用sendMessage->sendMessageDelayed->sendMessageAtTime，最后走到了sendMessageAtTime这个方法中。

 public final boolean sendMessage(Message msg){
        return sendMessageDelayed(msg, 0);
 }

public final boolean sendMessageDelayed(Message msg, long delayMillis){
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}

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

sendMessageAtTime中将Message入队，也就是放入到MessageQueue，MessageQueue是一个由链表实现的消息队列。

发送一个Runnable过程：

    public final boolean post(Runnable r) {
        return sendMessageDelayed(getPostMessage(r), 0);
    }

    //该方法把Runnable转换成Message
    private static Message getPostMessage(Runnable r) {
        Message m = Message.obtain();
        m.callback = r;
        return m;
    }

接下来走到sendMessageDelayed，以Message的方式继续处理

在sendMessageAtTime中调用了enqueueMessage（queue,msg,uptimeMillis）方法，在这个方法中进行了入队操作：

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

而真正的入队操作则到了MessageQueue中，代码如下：

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

看到prev=p、p = p.next、msg.next=p、prev.next=msg， 这不就是链表吗？所以MessageQueue是以单链表的形式来存储Message

到此为止：

消息已经发出去了，也存到了MessageQueue中等待被处理了，那么问题来了： 
1. MessageQueue是被谁处理的？ 
2. 被怎么处理的？

这个时候Looper就隆重登场了！

在主线程中创建了我们的Handler

handler = new UpdateHandler(this);

追踪源码，此处调用的是Handler默认的构造方法，源码如下：

 /**
     * Default constructor associates this handler with the {@link Looper} for the
     * current thread.
     * <p>
     * If this thread does not have a looper, this handler won't be able to receive messages
     * so an exception is thrown.
     */
    public Handler() {
        this(null, false);
    }

注释告诉我们:

默认的构造方法已经关联了一个当前线程的Looper
如果是我们自己启动的线程，不自己准备Looper的话就会抛出异常：Can’t create handler inside thread that has not called Looper.prepare() 

接下来调用：

public Handler(Callback callback, boolean async) {

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

在主线程启动的时候，已经为我们准备了一个默认的主线程使用的Looper，在ActivityThread中，有如下代码：

public static void main(String[] args) {
        ......

        Looper.prepareMainLooper();

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

        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.loop();

        ......
}

其中的两句代码，就可以帮我们揭秘——上面提到的两个问题：

MessageQueue中的消息是被谁处理的？
怎么被处理的？

其中的代码：

Looper.prepareMainLooper();
...
if (sMainThreadHandler == null) {
   sMainThreadHandler = thread.getHandler();
}
Looper.loop();

这就是为什么，我们在Activity中的OnCreate方法中创建了Handler但是并没有调用Looper.prepre（）和Looper.loop()但是没问题的原因，使用的是主线程Looper。

下面看看两个方法，先看看prepareMainLooper：

    //为当前线程创建一个Looper，Android环境已经为你准备好了，不需要再调用这个方法。 
    public static void prepareMainLooper() {
        prepare(false);
        synchronized (Looper.class) {
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            sMainLooper = myLooper();
        }
   }

这个方法中调用了prepare(false)方法：

 private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        //创建一个Looper，并设置给ThreadLocal
        sThreadLocal.set(new Looper(quitAllowed));
 }

ThreadLocal：现场内部的数据存储类，以线程为单元存储数据，此处在每个现场里都存了Looper。

很好奇new Looper(quitAllowed)这句代码做了什么，点击去看看：

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

一个private方法，我们无法new出一个Looper来，其中包含一个MessageQueue和当前的线程！因为当前线程是主线程，所以MessageQueue，Looper都是在主线程中。

在prepareMainLooper方法的最后，调用了myLooper()方法：

/**
 * 返回当前线程关联的Looper对象，如果当前线程没有关联Looper对象那么就返回null.
*/
public static @Nullable Looper myLooper() {
        return sThreadLocal.get();
}

至此，Looper.prepare()方法分析完毕，已经为主线程准备好了Looper。

接下来看，Looper.loop()方法：

  /**
  *  轮询当前线程的消息队列。在轮询完成之后确保调用了quit()方法。
  */
  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;

        ......
        //死循环
        for (;;) {
            Message msg = queue.next(); // 可能会阻塞，从MessageQueue中获取下一个消息
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }

           ......
            try {
                //msg.target 就是Handler，从MessageQueue中获取到的Message，被分发给了Handler中的dispatchMessage方法
                msg.target.dispatchMessage(msg);
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }

           ......
        }
    }

在Looper.loop()方法中，我们找到了答案：

阻塞式的获取消息队列中的Message。然后，调用Handler中的dispatchMessage进行Message的分发。

下面看看dispatchMessage的代码：

     /**
     * 在这儿处理系统Message
     */
    public void dispatchMessage(Message msg) {
        if (msg.callback != null) {   //处理runnable
            handleCallback(msg);
        } else {
            if (mCallback != null) { //new Hanlder(CallBack)处理callBack
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);     //处理message
        }
    }

接下来子类实现handlerMessage方法来处理消息：

     /**
     * 子类应该实现这个方法，来接收消息
     */
    public void handleMessage(Message msg) {
    }

最后消息，在子类的handlerMessage方法中被处理了！

处理Runnable：

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

Message数据结构：

    public class Message{

           Handler target;
           Runnable callback;
    }

这样Android中的消息机制的源码就分析完毕了，下面来回答刚开始提出的问题！
问题揭秘

1. Message在哪儿发出的

在子线程中发出的消息，通过如下代码：

Message msg = new Message();
msg.what = 1;
msg.obj = "加载完成";
handler.sendMessage(msg);

2. Message发到哪儿去了？

Message发送到了MessageQueue中，一个消息队列中！单链表的形式存储数据

3. Message最后怎么被处理的？

Message被Looper的Loop方法从MessageQueue中借助next()方法取出，分发给Handler中的dispatchMessage方法，进行处理。这是一个典型的生产者、消费者模型！

4. 怎么就把子线程发出的消息变换到了主线程中？

子线程把Message发送到了MessageQueue中，MessageQueue在Looper中初始化，Looper在主线程中，所以MessageQueue也在主线程中，消息就这样被变换到了主线程中。

5. 上面各个类都是什么作用呢？

Handler：发送消息、处理消息
Looper：消息泵，用来从MessageQueue中读取消息
MessageQueue：消息队列，存储Message。内部用链表实现
Message：主线程和子线程之间的通信载体
ThreadLocal: 线程内部的数据存储类，在指定的线程中存储数据，以线程为单元。

Handler在什么线程中创建，Handler就在什么线程，Looper、Message也在该线程工作。UI线程默认有Handler、Looper，并开启了消息循环；在子线程中默认没有Looper，需要创建Looper，并开启消息循环，方式如下：

Looper.prepare（）;     //创建Looper，Looper以线程为单元
hanlder = new Hanlder();
Looper.loop（）；       //开启消息循环

至此，Android消息机制的源码就分析完毕！