移动架构----Android消息机制

前言

• Android的消息机制主要是指Handler的运行机制
• Handler在工作中普遍会用到，在面试中也是常见的面试题之一。

1、 Android消息机制模型

原理图.png

以上模型的解释：

1. 以Handler的sendMessage方法为例，当发送一个消息后，会将此消息加入消息队列MessageQueue中。
2. Looper负责去遍历消息队列并且将消息队列中的消息分发给对应的Handler进行处理。
3. 在Handler的handleMessage方法中处理该消息，这就完成了一个消息的发送和处理过程。
   这里从图中可以看到参与消息处理有四个对象：Handler、Message、MessageQueue、Looper。

2、代码分析----ThreadLocal

在分析图上涉及到的四个对象之前，先分析一下背后默默工作的一个类：ThreadLocal。

定义

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

例子

  public void test() {
    //创建一个本地线程
    ThreadLocal<String> threadLocal = new ThreadLocal<String>() {
        @Override
        protected String initialValue() {
            //重写初始化方法，默认返回null
            return "XXXX";
        }
    };

    System.out.println("线程threadlocal:" + threadLocal.get());
}

打印结果：线程threadlocal:XXXX
现在分析代码流程，看一下最终是如何打印的"XXXX"，首先看一下ThreadLocal的get方法：

//ThreadLocal的get方法
public T get() {
    Thread t = Thread.currentThread();//获取到当前线程  
    //获取当前线程的threadLocals属性，注释1
    ThreadLocalMap map = getMap(t);
    //在此之前并没有为当前线程的threadLocals属性赋值，所以map为null，跳过if判断
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();//<-----进入，注释2
}
//注释1：获取当前线程的ThreadLocalMap属性
ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}
//注释2：
private T setInitialValue() {
    T value = initialValue();//子类覆盖的方法，这里子类返回的是"XXXX"
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    //同上，这里map也未曾赋值，map为null，跳过
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);//<----进入，注释3
    return value;//返回子类返回的值，及"XXXX"
}
 //注释3：为当前线程的threadLocals属性赋值
 //ThreadLocalMap的key为ThreadLocal自己，value为子类覆盖initialValue方法返回的值
void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

总结：调用ThreadLocal中的get方法时，先会取当前线程中的threadLocals属性，如果为空的话，则会执行ThreadLocal中的initalValue方法，然后调用createMap方法为当前线程的threadLocals赋值，最终把initalValue的值返回。

接下来看下个例子：

    Thread thread = new Thread(new Runnable() {
        @Override
        public void run() {
            String value = threadLocal.get();
            System.out.println("thread_1:" + value);

            threadLocal.set("YYYY");
            String value2 = threadLocal.get();
            System.out.println("thread_1:" + value2);
        }
    });
    thread.start();

打印结果：
thread_1:XXXX
thread_1:YYYY
分析：
第一次打印的结果是"XXXX"，原理同上面例子的总结；
第二次打印的结果是"YYYY"，看下ThreadLocal的set方法：

public void set(T value) {
    Thread t = Thread.currentThread();
    //这里map已经赋值，所以map不为空
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);//修改以当前线程对应的ThreadLocal为key的value值，即"XXXX"改为"YYYY"。
    else
        createMap(t, value);
}

再回到get方法：

public T get() {
    Thread t = Thread.currentThread();
    //map不为空
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;//返回map中对应的value值
            return result;
        }
    }
    return setInitialValue();
}

总结：ThreadLocal的set方法修改当前线程相关的ThreadLocal对象对应的value。

3、流程分析

分析完ThreadLocal是如何工作的，接下来看一下ThreadLocal在Handler中是如果摸摸工作的。

启动App，Looper初始化

启动App时Looper开始工作.png

App启动的入口时ActivityThread类的main方法，在main方法中调用Looper.prepareMainLooper对Looper进行初始化操作(关键代码)：

//ActivityThread类：
public static void main(String[] args) {
    ...
    Looper.prepareMainLooper();
    ...
    Looper.loop();
    ...
}

//Looper类
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
public static void prepareMainLooper() {
    prepare(false);
    synchronized (Looper.class) {
        if (sMainLooper != null) {
            throw new IllegalStateException("The main Looper has already been prepared.");
        }
        sMainLooper = myLooper();
    }
}
//创建主线程Looper对象
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));
}
//创建了主线程Looper对应的消息队列
private Looper(boolean quitAllowed) {
    mQueue = new MessageQueue(quitAllowed);
    mThread = Thread.currentThread();
}

创建handler

创建Handler.png

关键代码：

//(以主线程为例)
public Handler(@Nullable Callback callback, boolean async) {
    ...
    mLooper = Looper.myLooper();//获取当前线程对应的Looper
    ...
    mQueue = mLooper.mQueue;//获取当前线程消息队列
    ...
}

消息发送

消息发送.png

消息的发送，最后会调用Handler的enqueueMessage方法：

//Handler类:
private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
        long uptimeMillis) {
    //将handler赋值给msg的target属性
    msg.target = this;
    ....
    //调用MessageQueue中的enqueueMessage方法，将消息加入消息队列中
    return queue.enqueueMessage(msg, uptimeMillis);
}

消息处理

Looper轮询消息队列

Looper轮询消息队列.png

关键代码：

//Looper类：
public static void loop() {
    ...
    for (;;) {
        Message msg = queue.next(); // might block
        ...
        //msg.target为Handler对象，即这里调用handler的dispatchMessage方法分发消息
        msg.target.dispatchMessage(msg);
        ...
    }
}
//Handler类：
public void dispatchMessage(@NonNull Message msg) {
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        //执行创建Handler时重写的handleMessage方法。
        handleMessage(msg);
    }
}

到这里，Handler机制就算是大体的讲完了。
此只作为笔记，有不准确的的地方希望指正，谢谢！