Android Handler机制

        Android开发中经常用到handler来发送消息，比如将消息抛到主线程去更新UI。handler机制涉及到四个核心的类：

• Looper：消息循环，有一个Messagequenue，不断从消息队列中取出消息；
• MessageQuenue：消息队列，里边包含Message；
• Message：消息，里边有一个Handler，负责处理该消息；
• Handler：管理消息队列，里边有Looper和MessageQueue；

       

        为了更好的理解这三者的关系，我们可以想象成现实生活中，工厂里边的一条流水线。有一个放产品（Message）的传送带（MessageQuenue），被机器带动起来不断循环运行（Looper），而工人（Handler）需要将产品放到传送带上，然后传送到指定位置时再将产品进行下一步处理。

        从上述表达的关系可以看出，有一个MessageQuenue，可以往里边仍Message，而Looper则要让MessageQuenue转起来，不断从里边取消息；而Handler负责把Message放到队列里边，最后再处理这个消息。

注：以下源码基于Android 9.0(版本名称:  Pie     API Level:  28)。

Looper类分析
frameworks/base/core/java/android/os/Looper.java    
在该文件中给我们提供了一个实例：
 

  * <pre>
  *  class LooperThread extends Thread {
  *      public Handler mHandler;
  *
  *      public void run() {
  *          // ①调用prepare
  *          Looper.prepare();
  *
  *          mHandler = new Handler() {
  *              public void handleMessage(Message msg) {
  *                  // process incoming messages here
  *              }
  *          };
  *          // ② 进入消息循环
  *          Looper.loop();
  *      }
  *  }</pre>

上述使用了Looper的两个关键调用（①和②），下面逐一分析。

Looper准备：

    public static void prepare() {
        prepare(true);
    }
    private static void prepare(boolean quitAllowed) {
        // 一个Looper只能调用一次prepare
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        // 构造一个Looper对象，设置到调用线程的局部变量中
        sThreadLocal.set(new Looper(quitAllowed));
    }
    // sThreadLocal定义
    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

ThreadLocal是一个泛型，是Java线程中的局部变量。全名是Thread Local Variable。具体可以自行研究源码：libcore/ojluni/src/main/java/java/lang/ThreadLocal.java

Looper构造函数：

    private Looper(boolean quitAllowed) {
        // 构造一个消息队列
        mQueue = new MessageQueue(quitAllowed);
        // 获取当前线程的Thread对象
        mThread = Thread.currentThread();
    }

prepare主要创建了Looper对象，并保存在调用线程的ThreadLocal中。同时Looper对象内部封装了一个消息队列。prepare通过ThreadLocal机制将Looper和调用线程关联。Looper循环：

    /**
     * Run the message queue in this thread. Be sure to call
     * {@link #quit()} to end the loop.
     */
    public static void loop() {
        // 返回保存在调用线程的TLV中的Looper对象。
        final Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        // 取出Looper的消息队列
        final MessageQueue queue = me.mQueue;

        // ... 细节省略

        for (; ; ) {
            // 从消息队列中取出消息
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }
            // ... 细节省略
            try {
                // 调用该消息的Handler，交给它的dispatchMessage函数处理
                msg.target.dispatchMessage(msg);
                dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }
            // ... 细节省略
            msg.recycleUnchecked();
        }
    }

    /**
     * Return the Looper object associated with the current thread.  Returns
     * null if the calling thread is not associated with a Looper.
     *      
     */
    public static @Nullable
    Looper myLooper() {
        return sThreadLocal.get();
    }

通过上面源码分析可以了解到Looper的作用：

• 封装一个消息队列(Messagequenue)；
• Looper的prepare函数将Looper和调用prepare的线程(即处理线程)绑定；
• loop函数启动一个无线循环来处理消息队列中的消息。

        当事件源向这个Looper发送消息的时候，其实是把消息加到这个Looper的消息队列里了。那么，该消息就将由和Looper绑定的处理线程来处理。可事件源又是怎么向Looper消息队列添加消息的呢？下面需要了解Looper、Message、Handler的关系。

• Looper中有一个Message队列，里边存储的是一个个待处理的Message；
• Message中有一个Handler，这个Handler是用来处理Message的。

其中Handler类封装了很多琐碎的工作。具体：

frameworks/base/core/java/android/os/Handler.java

    final Looper mLooper;    // 有一个Looper
    final MessageQueue mQueue;    // 有一个消息队列
    final Callback mCallback;    // 有一个回调用的类
    final boolean mAsynchronous;  // 异步相关设置，本文不做分析

Handler有几个构造函数，主要区别是对上面三个重要成员变量初始化上。

    // 构造函数1
    public Handler() {
        this(null, false);
    }

    // 构造函数2
    public Handler(Callback callback) {
        this(callback, false);
    }
    // 构造函数3
    public Handler(Looper looper) {
        this(looper, null, false);
    }
    // 构造函数4
    public Handler(Looper looper, Callback callback) {
        this(looper, callback, false);
    }
    // 构造函数5
    public Handler(boolean async) {
        this(null, async);
    }

    public Handler(Callback callback, boolean async) {
        // ... 细节省略
        // 获得调用线程的Looper
        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread " + Thread.currentThread()
                        + " that has not called Looper.prepare()");
        }
        // 得到Looper的消息队列
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

    public Handler(Looper looper, Callback callback, boolean async) {
        mLooper = looper;
        mQueue = looper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

        上述构造函数中，Handler中的消息队列变量最终都会指向Looper的消息队列，Handler提供了一系列函数，帮助我们完成创建消息和插入消息队列的工作。这里列出一部分分析：

// 查看消息队列中是否有消息码是what的消息
public final boolean hasMessages(int what)
// 从Handler中创建一个消息码是what的消息
public final Message obtainMessage(int what)
// 从消息队列中移除消息码是what的消息
public final void removeMessages(int what)
// 发送一个只填充了消息码的消息
public final boolean sendEmptyMessage(int what)
// 发送一个消息，该消息添加到队列尾
public final boolean sendMessage(Message msg)
// 发送一个消息，该消息添加到队列头，所以优先级很高
public final boolean sendMessageAtFrontOfQueue(Message msg)

        以sendMessage为了，其代码实现如下所示：

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

    private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        // 把Message的target设为自己，然后加入到消息队列
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }

Handler的消息处理

        刚才，我们往Looper的消息队列中加入了一个消息，按照Looper的处理规则，它在获取消息后会调用target的dispatchMessage函数，再把这个消息派发给Handler处理。

    public void dispatchMessage(Message msg) {
        // 如果Message本身有callback，则直接交给Message的callback处理
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            // 如果本Handler设置mCallback，则交给mCallback处理
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            // 最后才交给子类处理
            handleMessage(msg);
        }
    }

        通常情况下，我们一般都是采用第三种方法，即在子类中通过重载handleMessage来完成处理工作。

        要理解Handler机制，主要是弄清楚Looper、MessageQuenue、Message、Handler之间的关系。为了便于理解，我们可以把这套框架想象成现实生活中工厂流水线，工人(Handler)拿到产品(Message)，放在传送带(MessageQuenue)上，同时做了一个标记(msg.target = this;)，传送带由机器带动(Looper)，然后当机器将产品传递到另一位置时，该员工根据产品上的标记，负责处理该产品，分发到不同的地方。

        上述分析细节可以自行查看Android源码，推荐网站：http://www.androidos.net.cn/sourcecode

扩展：

        Looper类里边启动了一个for(;;)循环，如果消息队列时会不会一直占用CPU时间片？

        循环中queue.next()函数里边用到了pipe/epoll机制，确保不会占用CPU时间片。之后会通过源码进行分析。