第10章 Android的消息机制

10.1 消息机制概述

1. 基本概念

   1. android消息机制就是Handler运行机制，Handler的运行需要底层的MessageQueue和Looper的支撑。
   2. MessageQueue内部的数据结构是单链表，对外是以消息队列的形成存在，提供插入和删除Message操作。
   3. Looper以无限循环的方式去MessageQueue查找有没有新的Message，如果有就处理，如果没有就等待。

2. Handler的主要作用是将一个任务切换到某个指定的线程中去执行。

   1. android 规定 UI只能主线程进行。会在ViewRootImpl的checkThread中验证Ui操作的线程。
   2. 为什么UI只能在主线程操作呢？因为UI组件非线程安全，多线程并发会有不可预期的问题；而如果加锁处理，会影响UI访问效率。

3. Handler的创建会采用当前线程的Looper来构建消息循环系统，所以建立Handler前必须要已经创建好Looper。

10.2 消息机制分析

10.2.1 ThreadLocal的工作原理

1. 当某些数据以线程为作用域而且不同线程具有不同的线程副本时，可以考虑才有ThreadLocal.
2. ThreadLocal是一个线程内部的数据存储类，通过它可以在指定的线程中存储数据；也只有在指定的线程中才可以获取到存储的数据，其他线程中无法获得到数据。
3. ThreadLocal原理
   1. set方法逻辑
      1. 找到Thread
      2. 找到Thread内的localValues，如果为空，则初始化
      3. 根据reference——index，向tables[index+1]中存储数据

   public void set(T value) {
       Thread currentThread = Thread.currentThread();
       Values values = values(currentThread);
       if (values == null) {
           values = initializeValues(currentThread);
       }
       values.put(this, value);
   }
   
   Values values(Thread current) {
       return current.localValues;
   }
   
   Values initializeValues(Thread current) {
       return current.localValues = new Values();
   }
   
   

   我们可以看到，localValues是Thread对象的一个Values类型的属性。
   localValues中有一个数组 Object[] table,ThreadLocal存储的值就存在这个table中，且table[index+1] = value（index为threadlocal.reference）
   2. get方法逻辑
      1. 找到Thread
      2. 找到Thread内的localValues，如果为空，则初始化localValues，并返回initialValue。
      3. 如果localValus不为空，根据reference——index，从tables[index+1]中取出数据

       public T get() {
       // Optimized for the fast path.
       Thread currentThread = Thread.currentThread();
       Values values = values(currentThread);
       if (values != null) {
           Object[] table = values.table;
           int index = hash & values.mask;
           if (this.reference == table[index]) {
               return (T) table[index + 1];
           }
       } else {
           values = initializeValues(currentThread);
       }
   
       return (T) values.getAfterMiss(this);
   }
   

10.2.2 消息队列的工作原理

1. MessageQueue的数据结构主要是单链表，实现了enqueueMessage（插入）和next（读取和删除）动作
2. 从原理上看
   1. enqueueMessage就是单链表的插入动作
   2. next是一个无限的循环，当有消息到来，next方法会返回这条消息并将其从单链表中移除；如果没有消息到来，next方法就会一直阻塞在这里

10.2.3 Looper的工作原理

1. 基本使用

new Thread("test"){
    @Override
    public void run() {
        Looper.prepare();//创建looper
        Handler handler = new Handler();//可以创建handler了
        Looper.loop();//开始looper循环
    }
}.start();

2. 主线程的Looper开发者一般不需要去prepare，已经由ActivityThread通过prepareMainLooper（）创建好了。
3. Looper提供一个getMainLooper()方法，这样就可以在任何地方获得主线程Looper。
4. Looper有quit()和quitSafely()。quitSafely需要将消息全部处理完毕后才安全退出。
5. 在不需要一直轮寻的时候，要适时quit Looper。
6. 当Looper调用loop()方法之后，消息循环系统才真正的起左右。
   Looper的loop方法会调用MessageQueue的next方法来获取新消息，而next是一个阻塞操作，当没有消息时，next方法会一直阻塞着在那里，这也导致了loop方法一直阻塞在那里。如果MessageQueue的next方法返回了新消息，Looper就会处理这条消息：msg.target.dispatchMessage(msg)，其中的msg.target就是发送这条消息的Handler对象。

10.2.4 Handler工作原理

1. Handler就是处理消息的发送和接收之后的处理；
2. Handler处理消息的过程

public void dispatchMessage(Message msg) {
    if (msg.callback != null) {
        handleCallback(msg);//当message是runnable的情况，也就是Handler的post方法传递的参数，这种情况下直接执行runnable的run方法
    } else {
        if (mCallback != null) {//如果创建Handler的时候是给Handler设置了Callback接口的实现，那么此时调用该实现的handleMessage方法
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        handleMessage(msg);//如果是派生Handler的子类，就要重写handleMessage方法，那么此时就是调用子类实现的handleMessage方法
    }
}

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

/**
 * Subclasses must implement this to receive messages.
 */
public void handleMessage(Message msg) {
}

3.Handler还有一个特殊的构造方法，它可以通过特定的Looper来创建Handler。

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

10.3 主线程的消息循环

1. Android的主线程就是ActivityThread，主线程的入口方法就是main，其中调用了Looper.prepareMainLooper()来创建主线程的Looper以及MessageQueue，并通过Looper.loop()方法来开启主线程的消息循环。
2. 主线程内有一个Handler，即ActivityThread.H，它定义了一组消息类型，主要包含了四大组件的启动和停止等过程，例如LAUNCH_ACTIVITY等。
3. ActivityThread通过ApplicationThread和AMS进行进程间通信，AMS以进程间通信的方法完成ActivityThread的请求后会回调ApplicationThread中的Binder方法，然后ApplicationThread会向H发送消息，H收到消息后会将ApplicationThread中的逻辑切换到ActivityThread中去执行，即切换到主线程中去执行，这个过程就是主线程的消息循环模型。