Android知识点 消息机制

Android消息机制

作用

Handler、Looper、MessageQueue 、Message这个类组成了一个异步消息处理机制。目的是用于不同线程间的通信。需要注意消息机制与线程池ThreadPoolExecutor作用的区别，消息机制让一个线程通知另外一个线程执行代码，而线程池是复用不同的Thread，提高性能，不需要线程间有联系。

原理

结构图

QQ20190424-174919.png

1. 在一个Thread中创建Looper（通过Looper.prepare()），
   prepare()中会调用Looper的构造函数，new MessageQueue，并使用ThreadLocal让Looper对象和Thread绑定，保持一对一关系。
2. 在Thread中new Handler，Handler会获取到Looper和MessageQueue，sendMessage通过MessageQueue入队Message。按照需求，复写Handler其中handleMessage的方法。
3. Looper.loop()会从MessageQueue取出Message，Message的target是Handler，dispatchMessage方法里会去执行handleMessage()。

源码

HandlerThread是一个已经初始化好Looper的Handy class，我们可以从HandlerThread中看看Looper的初始化流程，和上面说的过程是对应的。

//HandlerThread.java
public class HandlerThread extends Thread {
    Looper mLooper;
    private @Nullable Handler mHandler;
  
    public void run() {
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll();
        }
        onLooperPrepared();
      
        Looper.loop();
    }
  
    public Handler getThreadHandler() {
        if (mHandler == null) {
            mHandler = new Handler(getLooper());
        }
        return mHandler;
    }
}

主线程中也有类似的过程。

//ActivityThread.java
public static void main(String[] args) {
       Looper.prepareMainLooper();

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

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

接下来详细看一下代码是怎么走的，你最好也跟着在IDE中走走。

//使用者调用，如在HandlerThread.java中调用
Looper.prepare();

//Looper.java
    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));//使用静态变量sThreadLocal为当前线程保存Looper对象，形成一对一的关系
    }
    //构造函数是私有的，说明prepare是唯一new Looper()的方法
    private Looper(boolean quitAllowed) {
            mQueue = new MessageQueue(quitAllowed);//在这里new MessageQueue
            mThread = Thread.currentThread();
    }
//去ThreadLocal.java看看
    public void set(T value) { //T是Looper
        Thread t = Thread.currentThread();//当前线程
        ThreadLocalMap map = getMap(t);//每个Thread都有一个ThreadLocalMap成员变量
        if (map != null)
            map.set(this, value);//保存Looper对象。key是当前ThreadLocal对象，是Looper的静态成员变量，对于Looper类是唯一的。也就是为当前线程绑定了一个Looper对象。
        else
            createMap(t, value);
    }

//回到Looper.java
public static void loop() {
        final Looper me = myLooper();

        for (;;) {
            Message msg = queue.next(); // might block
            msg.target.dispatchMessage(msg); //msg的target属性是Handler。
            }
}

//使用者new Handler
//Handler.java
public Handler(Callback callback, boolean async) {
        mLooper = Looper.myLooper();//会自动获取Looper
       
        mQueue = mLooper.mQueue;
        mCallback = callback;
}
//使用者调post(Runnable r) sendMessage(Message msg) 等方法最后都会来到这。
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);//入队消息
 }

//被Looper.loop()调用
public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);//使用者会复写次方法，处理Message
        }
    }

ThreadLocal

为某个类和Thread进行一对一绑定，使该类可以成为类似成员变量的关系。
如Looper，使用ThreadLocal为了保证了每个线程有唯一的Looper。

通常在一个类中以private static成员变量来使用。

作用和继承Thread，增加一个新的成员变量差不多。但是不需要对Thread进行继承，在需要绑定的类中新增一个成员变量即可完成。

原理：Thread中有成员ThreadLocalMap，key为ThreadLocal对象，value为“成员变量的对象”

QQ20190424-174935.png

public final class Looper {
    static final ThreadLocal sThreadLocal = new ThreadLocal();
}

public class ThreadLocal {
      public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }
  
    public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this); //key是ThreadLocal对象
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();// t.threadLocals = new ThreadLocalMap(this, firstValue);帮线程初始化一个ThreadLocalMap
    }
 }

为什么主线程loop不会产生ANR？

主线程没有消息时阻塞(block)在管道的读端，有消息时，binder线程会往主线程消息队列里添加消息，然后往管道写端写一个字节。

参考

Android中为什么主线程不会因为Looper.loop()里的死循环卡死？ https://www.zhihu.com/question/34652589

IdleHandler 什么时候调用

/**
 * Callback interface for discovering when a thread is going to block
 * waiting for more messages.
 */
 public static interface IdleHandler {
 /**
 * Called when the message queue has run out of messages and will now
 * wait for more. Return true to keep your idle handler active, false
 * to have it removed. This may be called if there are still messages
 * pending in the queue, but they are all scheduled to be dispatched
 * after the current time.
 */
 boolean queueIdle();
 }

IdleHandler即在looper里面的message处理完了的时候去调用