Android知识体系之Handler

Android知识体系

总览

Handler 在整个 Android 开发体系中占据着很重要的地位，对开发者来说起到的作用很明确，就是为了实现线程切换或者是执行延时任务，稍微更高级一点的用法可能是为了保证多个任务在执行时的有序性。由于 Android 系统中的主线程有特殊地位，所以像 EventBus 和 Retrofit 这类并非 Android 独有的三方库，都是通过 Handler 来实现对 Android 系统的特殊平台支持。大部分开发者都已经对如何使用 Handler 很熟悉了，这里就再来了解下其内部具体是如何实现的

本文基于 Android API 30（即 Android 11）的系统源码进行讲解

一、动手实现 Handler

本文不会一上来就直接介绍源码，而是会先根据我们想要实现的效果来反推源码，一步步来自己动手实现一个简单的 Handler

1、Message

首先，我们需要有个载体来表示要执行的任务，就叫它 Message 吧，Message 应该有什么参数呢？

• 需要有一个唯一标识，因为要执行的任务可能有多个，我们要分得清哪个是哪个，用个 Int 类型变量就足够表示了
• 需要能够承载数据，需要发送的数据类型会有很多种可能，那就直接用一个 Object 类型变量来表示吧，由开发者自己在使用时再来强转类型
• 需要有一个 long 类型变量来表示任务的执行时间戳

所以，Message 类就应该至少包含以下几个字段：

/**
 * @Author: leavesC
 * @Date: 2020/12/1 13:31
 * @Desc:
 * GitHub：https://github.com/leavesC
 */
public final class Message {
    //唯一标识
    public int what;
    //数据
    public Object obj;
    //时间戳
    public long when;
}

2、MessageQueue

因为 Message 并不是发送了就能够马上被消费掉，所以就肯定要有个可以用来存放的地方，就叫它 MessageQueue 吧，即消息队列。Message 可能需要延迟处理，那么 MessageQueue 在保存 Message 的时候就应该按照时间戳的大小来顺序存放，时间戳小的 Message 放在队列的头部，在消费 Message 的时候就直接从队列头取值即可

那么用什么数据结构来存放 Message 比较好呢？

• 用数组？不太合适，数组虽然在遍历的时候会比较快，但需要预先就申请固定的内存空间，导致在插入数据和移除数据时可能需要移动大量数据。而 MessageQueue 可能随时会收到数量不定、时间戳大小不定的 Message，消费完 Message 后还需要将该其移出队列，所以使用数组并不合适
• 用链表？好像可以，链表在插入数据和移除数据时只需要改变指针的引用即可，不需要移动数据，内存空间也只需要按需申请即可。虽然链表在随机访问的时候性能不高，但是对于 MessageQueue 而言无所谓，因为在消费 Message 的时候也只需要取队列头的值，并不需要随机访问

好了，既然决定用链表结构，那么 Message 就需要增加一个字段用于指向下一条消息才行

/**
 * @Author: leavesC
 * @Date: 2020/12/1 13:31
 * @Desc:
 * GitHub：https://github.com/leavesC
 */
public final class Message {
    //唯一标识
    public int what;
    //数据
    public Object obj;
    //时间戳
    public long when;
    //下一个节点
    public Message next;
}

MessageQueue 需要提供一个 enqueueMessage方法用来向链表插入 Message，由于存在多个线程同时向队列发送消息的可能，所以方法内部还需要做下线程同步才行

/**
 * @Author: leavesC
 * @Date: 2020/12/1 13:31
 * @Desc:
 * GitHub：https://github.com/leavesC
 */
public class MessageQueue {
    //链表中的第一条消息
    private Message mMessages;
    void enqueueMessage(Message msg, long when) {
        synchronized (this) {
            Message p = mMessages;
            //如果链表是空的，或者处于队头的消息的时间戳比 msg 要大，则将 msg 作为链表头部
            if (p == null || when == 0 || when < p.when) {
                msg.next = p;
                mMessages = msg;
            } else {
                Message prev;
                //从链表头向链表尾遍历，寻找链表中第一条时间戳比 msg 大的消息，将 msg 插到该消息的前面
                for (; ; ) {
                    prev = p;
                    p = p.next;
                    if (p == null || when < p.when) {
                        break;
                    }
                }
                msg.next = p;
                prev.next = msg;
            }
        }
    }
}

此外，MessageQueue 要有一个可以获取队头消息的方法才行，就叫做next()吧。外部有可能会随时向 MessageQueue 发送 Message，next()方法内部就直接来开启一个无限循环来反复取值吧。如果当前队头的消息可以直接处理的话（即消息的时间戳小于或等于当前时间），那么就直接返回队头消息。而如果队头消息的时间戳比当前时间还要大（即队头消息是一个延时消息），那么就计算当前时间和队头消息的时间戳的差值，计算 next() 方法需要阻塞等待的时间，调用 nativePollOnce()方法来等待一段时间后再继续循环遍历

    //用来标记 next() 方法是否正处于阻塞等待的状态
    private boolean mBlocked = false;
    Message next() {
        int nextPollTimeoutMillis = 0;
        for (; ; ) {
            nativePollOnce(nextPollTimeoutMillis);
            synchronized (this) {
                //当前时间
                final long now = SystemClock.uptimeMillis();
                Message msg = mMessages;
                if (msg != null) {
                    if (now < msg.when) {
                        //如果当前时间还未到达消息的的处理时间，那么就计算还需要等待的时间
                        nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                    } else {
                        //可以处理队头的消息了，第二条消息成为队头
                        mMessages = msg.next;
                        msg.next = null;
                        mBlocked = false;
                        return msg;
                    }
                } else {
                    // No more messages.
                    nextPollTimeoutMillis = -1;
                }
                mBlocked = true;
            }
        }
    }
    //将 next 方法的调用线程休眠指定时间
    private void nativePollOnce(long nextPollTimeoutMillis) {
    }

此时就需要考虑到一种情形：当 next()还处于阻塞状态的时候，外部向消息队列插入了一个可以立即处理或者是阻塞等待时间比较短的 Message。此时就需要唤醒休眠的线程，因此 enqueueMessage还需要再改动下，增加判断是否需要唤醒next()方法的逻辑

    void enqueueMessage(Message msg, long when) {
        synchronized (this) {
            //用于标记是否需要唤醒 next 方法
            boolean needWake = false;         
            Message p = mMessages;
            //如果链表是空的，或者处于队头的消息的时间戳比 msg 要大，则将 msg 作为链表头部
            if (p == null || when == 0 || when < p.when) {
                msg.next = p;
                mMessages = msg;     
                //需要唤醒
                needWake = mBlocked;
            } else {
                Message prev;
                //从链表头向链表尾遍历，寻找链表中第一条时间戳比 msg 大的消息，将 msg 插到该消息的前面
                for (; ; ) {
                    prev = p;
                    p = p.next;
                    if (p == null || when < p.when) {
                        break;
                    }
                }
                msg.next = p;
                prev.next = msg;
            }  
            if (needWake) {
                //唤醒 next() 方法
                nativeWake();
            }
        }
    }
    //唤醒 next() 方法
    private void nativeWake() {
    }

3、Handler

既然存放消息的地方已经确定就是 MessageQueue 了，那么自然就还需要有一个类可以用来向 MessageQueue 发送消息了，就叫它 Handler 吧。Handler 可以实现哪些功能呢？

• 希望除了可以发送 Message 类型的消息外还可以发送 Runnable 类型的消息。这个简单，Handler 内部将 Runnable 包装为 Message 即可
• 希望可以发送延时消息，以此来执行延时任务。这个也简单，用 Message 内部的 when 字段来标识希望任务执行时的时间戳即可
• 希望可以实现线程切换，即从子线程发送的 Message 可以在主线程被执行，反过来也一样。这个也不难，子线程可以向一个特定的 mainMessageQueue 发送消息，然后让主线程负责循环从该队列中取消息并执行即可，这样不就实现了线程切换了吗？

所以说，Message 的定义和发送是由 Handler 来完成的，但 Message 的分发则可以交由其他线程来完成

根据以上需求：Runnable 要能够包装为 Message 类型，Message 的处理逻辑要交由 Handler 来定义，所以 Message 就还需要增加两个字段才行

/**
 * @Author: leavesC
 * @Date: 2020/12/1 13:31
 * @Desc:
 * GitHub：https://github.com/leavesC
 */
public final class Message {
    //唯一标识
    public int what;
    //数据
    public Object obj;
    //时间戳
    public long when;
    //下一个节点
    public Message next;
    //用于将 Runnable 包装为 Message
    public Runnable callback;
    //指向 Message 的发送者，同时也是 Message 的最终处理者
    public Handler target;
}

Handler 至少需要包含几个方法：用于发送 Message 和 Runnable 的方法、用来处理消息的 handleMessage 方法、用于分发消息的 dispatchMessage方法

/**
 * @Author: leavesC
 * @Date: 2020/12/1 13:31
 * @Desc:
 * GitHub：https://github.com/leavesC
 */
public class Handler {
    private MessageQueue mQueue;
    public Handler(MessageQueue mQueue) {
        this.mQueue = mQueue;
    }
    public final void post(Runnable r) {
        sendMessageDelayed(getPostMessage(r), 0);
    }
    public final void postDelayed(Runnable r, long delayMillis) {
        sendMessageDelayed(getPostMessage(r), delayMillis);
    }
    public final void sendMessage(Message r) {
        sendMessageDelayed(r, 0);
    }
    public final void sendMessageDelayed(Message msg, long delayMillis) {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    }
    public void sendMessageAtTime(Message msg, long uptimeMillis) {
        msg.target = this;
        mQueue.enqueueMessage(msg, uptimeMillis);
    }
    private static Message getPostMessage(Runnable r) {
        Message m = new Message();
        m.callback = r;
        return m;
    }
    //由外部来重写该方法，以此来消费 Message
    public void handleMessage(Message msg) {
    }
    //用于分发消息
    public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            msg.callback.run();
        } else {
            handleMessage(msg);
        }
    }
}

之后，子线程就可以像这样来使用 Handler 了：将子线程持有的 Handler 对象和主线程关联的 mainMessageQueue 绑定在一起，主线程负责循环从 mainMessageQueue 取出 Message 后再来调用 Handler 的 dispatchMessage 方法，以此实现线程切换的目的

        Handler handler = new Handler(mainThreadMessageQueue) {
            @Override
            public void handleMessage(Message msg) {
                switch (msg.what) {
                    case 1: {
                        String ob = (String) msg.obj;
                        break;
                    }
                    case 2: {
                        List<String> ob = (List<String>) msg.obj;
                        break;
                    }
                }
            }
        };
        Message messageA = new Message();
        messageA.what = 1;
        messageA.obj = "https://github.com/leavesC";
        Message messageB = new Message();
        messageB.what = 2;
        messageB.obj = new ArrayList<String>();
        handler.sendMessage(messageA);
        handler.sendMessage(messageB);

4、Looper

现在就再来想想怎么让 Handler 拿到和主线程关联的 MessageQueue，以及主线程怎么从 MessageQueue 获取 Message 并回调 Handler。这之间就一定需要一个中转器，就叫它 Looper 吧。Looper 具体需要实现什么功能呢？

• 每个 Looper 对象应该都是对应一个独有的 MessageQueue 实例和 Thread 实例，这样子线程和主线程才可以互相发送 Message 交由对方线程处理
• Looper 内部需要开启一个无限循环，其关联的线程就负责从 MessageQueue 循环获取 Message 进行处理
• 因为主线程较为特殊，所以和主线程关联的 Looper 对象要能够被子线程直接获取到，可以考虑将其作为静态变量存着

这样，Looper 的大体框架就出来了。通过 ThreadLocal 来为不同的线程单独维护一个 Looper 实例，每个线程通过 prepare()方法来初始化本线程独有的 Looper 实例 ，再通过 myLooper()方法来获取和当前线程关联的 Looper 对象，和主线程关联的 sMainLooper 作为静态变量存在，方便子线程获取

/**
 * @Author: leavesC
 * @Date: 2020/12/1 13:31
 * @Desc:
 * GitHub：https://github.com/leavesC
 */
final class Looper {
    final MessageQueue mQueue;
    final Thread mThread;
    private static Looper sMainLooper;
    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
    private Looper() {
        mQueue = new MessageQueue();
        mThread = Thread.currentThread();
    }
    public static void prepare() {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper());
    }
    public static void prepareMainLooper() {
        prepare();
        synchronized (Looper.class) {
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            sMainLooper = myLooper();
        }
    }
    public static Looper getMainLooper() {
        synchronized (Looper.class) {
            return sMainLooper;
        }
    }
    public static Looper myLooper() {
        return sThreadLocal.get();
    }
}

Looper 还需要有一个用于循环从 MessageQueue 获取消息并处理的方法，就叫它loop()吧。其作用也能简单，就是循环从 MessageQueue 中取出 Message，然后将 Message 再反过来分发给 Handler 即可

    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();//可能会阻塞
            msg.target.dispatchMessage(msg);
        }
    }

这样，主线程就先通过调用prepareMainLooper()来完成 sMainLooper 的初始化，然后调用loop()开始向 mainMessageQueue 循环取值并进行处理，没有消息的话主线程就暂时休眠着。子线程拿到 sMainLooper 后就以此来初始化 Handler，这样子线程向 Handler 发送的消息就都会被存到 mainMessageQueue 中，最终在主线程被消费掉

5、做一个总结

这样一步步走下来后，读者对于 Message、MessageQueue、Handler、Looper 这四个类的定位就应该都很清晰了吧？不同线程之间就可以依靠拿到对方的 Looper 来实现消息的跨线程处理了

例如，对于以下代码，即使 Handler 是在 otherThread 中进行初始化，但 handleMessage 方法最终是会在 mainThread 被调用执行的，

        Thread mainThread = new Thread() {
            @Override
            public void run() {
                //初始化 mainLooper
                Looper.prepareMainLooper();
                //开启循环
                Looper.loop();
            }
        };
        Thread otherThread = new Thread() {
            @Override
            public void run() {
                Looper mainLooper = Looper.getMainLooper();
                Handler handler = new Handler(mainLooper.mQueue) {
                    @Override
                    public void handleMessage(Message msg) {
                        switch (msg.what) {
                            case 1: {
                                String ob = (String) msg.obj;
                                break;
                            }
                            case 2: {
                                List<String> ob = (List<String>) msg.obj;
                                break;
                            }
                        }
                    }
                };
                Message messageA = new Message();
                messageA.what = 1;
                messageA.obj = "https://github.com/leavesC";
                Message messageB = new Message();
                messageB.what = 2;
                messageB.obj = new ArrayList<String>();
                handler.sendMessage(messageA);
                handler.sendMessage(messageB);
            }
        };

再来做个简单的总结：

• Message：用来表示要执行的任务
• Handler：子线程持有的 Handler 如果绑定到的是主线程的 MessageQueue 的话，那么子线程发送的 Message 就可以由主线程来消费，以此来实现线程切换，执行 UI 更新操作等目的
• MessageQueue：即消息队列，通过 Handler 发送的消息并非都是立即执行的，需要先按照 Message 的优先级高低（延时时间的长短）保存到 MessageQueue 中，之后再来依次执行
• Looper：Looper 用于从 MessageQueue 中循环获取 Message 并将之传递给消息处理者（即消息发送者 Handler 本身）来进行消费，每条 Message 都有个 target 变量用来指向 Handler，以此把 Message 和其处理者关联起来。不同线程之间通过互相拿到对方的 Looper 对象，以此来实现跨线程发送消息

有了以上的认知基础后，下面就来看看实际的源码实现 ~ ~

二、Handler 源码

1、Handler 如何初始化

Handler 的构造函数一共有七个，除去两个已经废弃的和三个隐藏的，实际上开发者可以使用的只有两个。而不管是使用哪个构造函数，最终的目的都是为了完成 mLooper、mQueue、mCallback、mAsynchronous 这四个常量的初始化，同时也可以看出来 MessageQueue 是由 Looper 来完成初始化的，而且 Handler 对于 Looper 和 MessageQueue 都是一对一的关系，一旦初始化后就不可改变

大部分开发者使用的应该都是 Handler 的无参构造函数，而在 Android 11 中 Handler 的无参构造函数已经被标记为废弃的了。Google 官方更推荐的做法是通过显式传入 Looper 对象来完成初始化，而非隐式使用当前线程关联的 Looper

Handler 对于 Looper 和 MessageQueue 都是一对一的关系，但是 Looper 和 MessageQueue 对于 Handler 可以是一对多的关系，这个后面会讲到

    @UnsupportedAppUsage
    final Looper mLooper;
    final MessageQueue mQueue;
    @UnsupportedAppUsage
    final Callback mCallback;
    final boolean mAsynchronous;
    //省略其它构造函数
    /**
     * @hide
     */
    public Handler(@Nullable Callback callback, boolean async) {
        if (FIND_POTENTIAL_LEAKS) {
            final Class<? extends Handler> klass = getClass();
            if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
                    (klass.getModifiers() & Modifier.STATIC) == 0) {
                Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
                    klass.getCanonicalName());
            }
        }
        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread " + Thread.currentThread()
                        + " that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

2、Looper 如何初始化

在初始化 Handler 时，如果外部调用的构造函数没有传入 Looper，那就会调用Looper.myLooper()来获取和当前线程关联的 Looper 对象，再从 Looper 中取 MessageQueue。如果获取到的 Looper 对象为 null 就会抛出异常。根据异常信息 Can't create handler inside thread that has not called Looper.prepare() 可以看出来，在初始化 Handler 之前需要先调用 Looper.prepare()完成 Looper 的初始化

走进 Looper 类中可以看到，myLooper()方法是 Looper 类的静态方法，其只是单纯地从 sThreadLocal 变量中取值并返回而已。sThreadLocal 又是通过 prepare(boolean) 方法来进行初始化赋值的，且只能赋值一次，重复调用将抛出异常

我们知道，ThreadLocal 的特性就是可以为不同的线程分别维护单独的一个变量实例，所以，不同的线程就会分别对应着不同的 Looper 对象，是一一对应的关系

    @UnsupportedAppUsage
    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>(); 
    /**
     * 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();
    }
    /** Initialize the current thread as a looper.
      * This gives you a chance to create handlers that then reference
      * this looper, before actually starting the loop. Be sure to call
      * {@link #loop()} after calling this method, and end it by calling
      * {@link #quit()}.
      */
    public static void prepare() {
        prepare(true);
    }
    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 类的构造函数也是私有的，会初始化两个常量值：mQueue 和 mThread，这说明了 Looper 对于 MessageQueue 和 Thread 都是一一对应的关系，关联之后不能改变

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

在日常开发中，我们在通过 Handler 来执行 UI 刷新操作时，经常使用的是 Handler 的无参构造函数，那么此时肯定就是使用了和主线程关联的 Looper 对象，对应 Looper 类中的静态变量 sMainLooper

    @UnsupportedAppUsage
    private static Looper sMainLooper;  // guarded by Looper.class
    //被标记为废弃的原因是因为 sMainLooper 会交由 Android 系统自动来完成初始化，外部不应该主动来初始化
    @Deprecated
    public static void prepareMainLooper() {
        prepare(false);
        synchronized (Looper.class) {
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            sMainLooper = myLooper();
        }
    }
    /**
     * Returns the application's main looper, which lives in the main thread of the application.
     */
    public static Looper getMainLooper() {
        synchronized (Looper.class) {
            return sMainLooper;
        }
    }

prepareMainLooper()就用于为主线程初始化 Looper 对象，该方法又是由 ActivityThread 类的 main() 方法来调用的。该 main() 方法即 Java 程序的运行起始点，所以当应用启动时系统就自动为我们在主线程做好了 mainLooper 的初始化，而且已经调用了Looper.loop()方法开启了消息的循环处理，应用在使用过程中的各种交互逻辑（例如：屏幕的触摸事件、列表的滑动等）就都是在这个循环里完成分发的

正是因为 Android 系统已经自动完成了主线程 Looper 的初始化，所以我们在主线程中才可以直接使用 Handler 的无参构造函数来完成 UI 相关事件的处理

public final class ActivityThread extends ClientTransactionHandler {
    public static void main(String[] args) {
        ···
        Looper.prepareMainLooper();
        ···
        Looper.loop();
        throw new RuntimeException("Main thread loop unexpectedly exited");
    }
}

3、Handler 发送消息

Handler 用于发送消息的方法非常多，有十几个，其中大部分最终调用到的都是 sendMessageAtTime() 方法。uptimeMillis 即 Message 具体要执行的时间戳，如果该时间戳比当前时间大，那么就意味着要执行的是延迟任务。如果为 mQueue 为 null，就会打印异常信息并直接返回，因为 Message 是需要交由 MessageQueue 来处理的

    public boolean sendMessageAtTime(@NonNull 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);
    }

需要注意 msg.target = this 这句代码，target 指向了发送消息的主体，即 Handler 对象本身，即由 Handler 对象发给 MessageQueue 的消息最后还是要交由 Handler 对象本身来处理

    private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
            long uptimeMillis) {
        msg.target = this;
        msg.workSourceUid = ThreadLocalWorkSource.getUid();
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        //将消息交由 MessageQueue 处理
        return queue.enqueueMessage(msg, uptimeMillis);
    }

4、MessageQueue

MessageQueue 通过 enqueueMessage 方法来接收消息

• 因为存在多个线程同时往一个 MessageQueue 发送消息的可能，所以 enqueueMessage 内部肯定需要进行线程同步
• 可以看出 MessageQueue 内部是以链表的结构来存储 Message 的（Message.next），根据 Message 的时间戳大小来决定其在消息队列中的位置
• mMessages 代表的是消息队列中的第一条消息。如果 mMessages 为空（消息队列是空的），或者 mMessages 的时间戳要比新消息的时间戳大，则将新消息插入到消息队列的头部；如果 mMessages 不为空，则寻找消息列队中第一条触发时间比新消息晚的非空消息，将新消息插到该消息的前面

到此，一个按照时间戳大小进行排序的消息队列就完成了，后边要做的就是从消息队列中依次取出消息进行处理了

    boolean enqueueMessage(Message msg, long when) {
        if (msg.target == null) {
            throw new IllegalArgumentException("Message must have a target.");
        }
        synchronized (this) {
            ···
            msg.markInUse();
            msg.when = when;
            Message p = mMessages;
            //用于标记是否需要唤醒线程
            boolean needWake;
            //如果链表是空的，或者处于队头的消息的时间戳比 msg 要大，则将 msg 作为链表头部
            //when == 0 说明 Handler 调用的是 sendMessageAtFrontOfQueue 方法，直接将 msg 插到队列头部 
            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 {
                //如果当前线程处于休眠状态 + 队头消息是屏障消息 + msg 是异步消息
                //那么就需要唤醒线程
                needWake = mBlocked && p.target == null && msg.isAsynchronous();
                Message prev;
                //从链表头向链表尾遍历，寻找链表中第一条时间戳比 msg 大的消息，将 msg 插到该消息的前面
                for (;;) {
                    prev = p;
                    p = p.next;
                    if (p == null || when < p.when) {
                        break;
                    }
                    if (needWake && p.isAsynchronous()) {
                        //如果在 msg 之前队列中还有异步消息那么就不需要主动唤醒
                        //因为已经设定唤醒时间了
                        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;
    }

知道了 Message 是如何保存的了，再来看下 MessageQueue 是如何取出 Message 并回调给 Handler 的。在 MessageQueue 中读取消息的操作对应的是next() 方法。next() 方法内部开启了一个无限循环，如果消息队列中没有消息或者是队头消息还没到可以处理的时间，该方法就会导致 Loop 线程休眠挂起，直到条件满足后再重新遍历消息

    @UnsupportedAppUsage
    Message next() {
        ···
        for (;;) {
            if (nextPollTimeoutMillis != 0) {
                Binder.flushPendingCommands();
            }
            //将 Loop 线程休眠挂起
            nativePollOnce(ptr, nextPollTimeoutMillis);
            synchronized (this) {
                // Try to retrieve the next message.  Return if found.
                final long now = SystemClock.uptimeMillis();
                Message prevMsg = null;
                Message msg = mMessages;
                if (msg != null && msg.target == null) {
                    // Stalled by a barrier.  Find the next asynchronous message in the queue.
                    do {
                        prevMsg = msg;
                        msg = msg.next;
                    } while (msg != null && !msg.isAsynchronous());
                }
                if (msg != null) {
                    if (now < msg.when) {
                        //队头消息还未到处理时间，计算需要等待的时间
                        // Next message is not ready.  Set a timeout to wake up when it is ready.
                        nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                    } else {
                        // Got a message.
                        mBlocked = false;
                        if (prevMsg != null) {
                            prevMsg.next = msg.next;
                        } else {
                            mMessages = msg.next;
                        }
                        msg.next = null;
                        if (DEBUG) Log.v(TAG, "Returning message: " + msg);
                        msg.markInUse();
                        return msg;
                    }
                } else {
                    // No more messages.
                    nextPollTimeoutMillis = -1;
                }
                ···
            }
            ···
            }
            ···
        }
    }

next() 方法又是通过 Looper 类的 loop() 方法来循环调用的，loop() 方法内也是一个无限循环，唯一跳出循环的条件就是 queue.next()方法返回为 null。因为 next() 方法可能会触发阻塞操作，所以没有消息需要处理时也会导致 loop() 方法被阻塞着，而当 MessageQueue 有了新的消息，Looper 就会及时地处理这条消息并调用 msg.target.dispatchMessage(msg) 方法将消息回传给 Handler 进行处理

    /**
     * Run the message queue in this thread. Be sure to call
     * {@link #quit()} to end the loop.
     */
    public static void loop() {
        final Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        ··· 
        for (;;) {
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }
            ···
            msg.target.dispatchMessage(msg);
            ···
        }
    }

Handler 的dispatchMessage方法就是在向外部分发 Message 了。至此，Message 的整个分发流程就结束了

    /**
     * Handle system messages here.
     */
    public void dispatchMessage(@NonNull Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }

5、消息屏障

Handler的Message种类分为3种：

• 同步消息
• 屏障消息
• 异步消息

同步消息

我们通常使用的都是同步消息

Handler mHandler = new Handler();
mHandler.sendMessage();
mHandler.post()

异步消息

Handler 的构造函数中的async参数就用于控制发送的 Message 是否属于异步消息

    public class Handler {
        final boolean mAsynchronous;
        public Handler(boolean async) {
            this(null, async);
        }
        public Handler(Callback callback, boolean async) {
            ...
        }
        public Handler(@NonNull Looper looper, @Nullable Callback callback, boolean async) {
            ···
            mAsynchronous = async;
        }
        private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
                long uptimeMillis) {
            msg.target = this;
            msg.workSourceUid = ThreadLocalWorkSource.getUid();
            if (mAsynchronous) {
                //设为异步消息
                msg.setAsynchronous(true);
            }
            return queue.enqueueMessage(msg, uptimeMillis);
        }
    }

当然，也可以直接调用Message#setAsynchronous(true)。

屏障消息

屏障消息又称为同步屏障，屏障消息就是在消息队列中插入一个屏障，在屏障之后的所有同步消息都会被挡着，不能被处理。
屏障消息就是为了确保异步消息的优先级，设置了屏障后，只能处理其后的异步消息，同步消息会被挡住，除非撤销屏障。

插入消息屏障

同步屏只能通过MessageQueue#postSyncBarrier来插入到消息队列中，这个系统内部方法，我们是调用不到的：

private int postSyncBarrier(long when) {
        synchronized (this) {
            final int token = mNextBarrierToken++;
            //1、屏障消息和普通消息的区别是屏障消息没有tartget。
            final Message msg = Message.obtain();
            msg.markInUse();
            msg.when = when;
            msg.arg1 = token;
            Message prev = null;
            Message p = mMessages;
            //2、根据时间顺序将屏障插入到消息链表中适当的位置
            if (when != 0) {
                while (p != null && p.when <= when) {
                    prev = p;
                    p = p.next;
                }
            }
            if (prev != null) { // invariant: p == prev.next
                msg.next = p;
                prev.next = msg;
            } else {
                msg.next = p;
                mMessages = msg;
            }
            //3、返回一个序号，通过这个序号可以撤销屏障
            return token;
        }
}

• 屏障消息和普通消息的区别在于屏障没有tartget，普通消息有target是因为它需要将消息分发给对应的target，而屏障不需要被分发，它就是用来挡住普通消息来保证异步消息优先处理的。
• 屏障和普通消息一样可以根据时间来插入到消息队列中的适当位置，并且只会挡住它后面的同步消息的分发。
• postSyncBarrier返回一个int类型的数值，通过这个数值可以撤销屏障。
• postSyncBarrier方法是私有的，如果我们想调用它就得使用反射。
  插入普通消息会唤醒消息队列，但是插入屏障不会。
• 只要屏障消息存在，同步消息就不会被执行到，会一直

读取消息屏障

MessageQueue 在取队头消息的时候，如果判断到队头消息就是屏障消息的话，那么就会向后遍历找到第一条异步消息优先进行处理

    @UnsupportedAppUsage
    Message next() {
        ···
        for (;;) {
            if (nextPollTimeoutMillis != 0) {
                Binder.flushPendingCommands();
            }
            nativePollOnce(ptr, nextPollTimeoutMillis);
            synchronized (this) {
                // Try to retrieve the next message.  Return if found.
                final long now = SystemClock.uptimeMillis();
                Message prevMsg = null;
                Message msg = mMessages;
                if (msg != null && msg.target == null) { //target 为 null 即属于屏障消息
                    // Stalled by a barrier.  Find the next asynchronous message in the queue.
                    //循环遍历，找到屏障消息后面的第一条异步消息进行处理
                    do {
                        prevMsg = msg;
                        msg = msg.next;
                    } while (msg != null && !msg.isAsynchronous());
                }
                ···
            }
            ···
        }
    }

移除消息屏障

同步消息要想执行，必须先移除消息屏障，需要调用MessageQueue#removeSyncBarrier

public void removeSyncBarrier(int token) {
        // Remove a sync barrier token from the queue.
        // If the queue is no longer stalled by a barrier then wake it.
        synchronized (this) {
            Message prev = null;
            Message p = mMessages;
            while (p != null && (p.target != null || p.arg1 != token)) {
                prev = p;
                p = p.next;
            }
            if (p == null) {
                throw new IllegalStateException("The specified message queue synchronization "
                        + " barrier token has not been posted or has already been removed.");
            }
            final boolean needWake;
            if (prev != null) {
                prev.next = p.next;
                needWake = false;
            } else {
                mMessages = p.next;
                needWake = mMessages == null || mMessages.target != null;
            }
            p.recycleUnchecked();
            // If the loop is quitting then it is already awake.
            // We can assume mPtr != 0 when mQuitting is false.
            if (needWake && !mQuitting) {
                nativeWake(mPtr);
            }
        }
    }

同步屏障使用场景

Android 系统中的 UI 更新相关的消息都是异步消息，确保优先执行

比如，在 View 更新时，draw、requestLayout、invalidate 等很多地方都调用了ViewRootImpl#scheduleTraversals()，如下：

//ViewRootImpl.java
void scheduleTraversals() {
    if (!mTraversalScheduled) {
        mTraversalScheduled = true;
        //开启同步屏障
        mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
        //发送异步消息
        mChoreographer.postCallback(
                Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
        if (!mUnbufferedInputDispatch) {
            scheduleConsumeBatchedInput();
        }
        notifyRendererOfFramePending();
        pokeDrawLockIfNeeded();
    }
}

mHandler.getLooper().getQueue().postSyncBarrier()开启了同步屏障，然后发送了异步消息

void doTraversal() {
    if (mTraversalScheduled) {
        mTraversalScheduled = false;
        // 移除同步屏障
        mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier);
        if (mProfile) {
            Debug.startMethodTracing("ViewAncestor");
        }
        performTraversals();
        if (mProfile) {
            Debug.stopMethodTracing();
            mProfile = false;
        }
    }
}

mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier);移除了同步屏障

6、退出 Looper 循环

Looper 类本身做了方法限制，除了主线程外，子线程关联的 MessageQueue 都支持退出 Loop 循环，即 quitAllowed 只有主线程才能是 false

public final class Looper {
    private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    }
    public void quit() {
        mQueue.quit(false);
    }
    public void quitSafely() {
        mQueue.quit(true);
    }
}

MessageQueue 支持两种方式来退出 Loop：

• safe 为 true，只移除所有尚未执行的消息，不移除时间戳等于当前时间的消息
• safe 为 false，移除所有消息

    void quit(boolean safe) {
        if (!mQuitAllowed) {
            //MessageQueue 设置了不允许退出循环，直接抛出异常
            throw new IllegalStateException("Main thread not allowed to quit.");
        }
        synchronized (this) {
            if (mQuitting) {
                //避免重复调用
                return;
            }
            mQuitting = true;
            if (safe) {
                //只移除所有尚未执行的消息，不移除时间戳等于当前时间的消息
                removeAllFutureMessagesLocked();
            } else {
                //移除所有消息
                removeAllMessagesLocked();
            }
            // We can assume mPtr != 0 because mQuitting was previously false.
            nativeWake(mPtr);
        }
    }

mQuitting会被置为true，然后在enqueueMessage和next都会使用到这个变量：

boolean enqueueMessage(Message msg, long when) {
    ...
    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;
            }
    ...
}

Message next() {
    ...
    synchronized (this) {
        if (mQuitting) {
            dispose();
            return null;
        }
    }
}

MessagQueue退出了，但是我们知道Looper也是一个死循环，它是怎么退出的呢？
注意这里next方法直接会返回null，我们来看loop方法：

public static void loop() {
    ...
    for (;;) {
        Message msg = queue.next(); // might block
        if (msg == null) {
            // No message indicates that the message queue is quitting.
            return;
        }
       ...     
    }
}

当得到的Message为null的时候，就直接退出了

7、IdleHandler

IdleHandler 是 MessageQueue 的一个内部接口，可以用于在 Loop 线程处于空闲状态的时候执行一些优先级不高的操作

    public static interface IdleHandler {
        boolean queueIdle();
    }

MessageQueue 在获取队头消息时，如果发现当前没有需要执行的 Message 的话，那么就会去遍历 mIdleHandlers，依次执行 IdleHandler

    private final ArrayList<IdleHandler> mIdleHandlers = new ArrayList<IdleHandler>();
    @UnsupportedAppUsage
    Message next() {
        ···
        int pendingIdleHandlerCount = -1; // -1 only during first iteration
        int nextPollTimeoutMillis = 0;
        for (;;) {
            ···
            synchronized (this) {
                ···
                //如果队头消息 mMessages 为 null 或者 mMessages 需要延迟处理
                //那么就来执行 IdleHandler
                if (pendingIdleHandlerCount < 0
                        && (mMessages == null || now < mMessages.when)) {
                    pendingIdleHandlerCount = mIdleHandlers.size();
                }
                if (pendingIdleHandlerCount <= 0) {
                    // No idle handlers to run.  Loop and wait some more.
                    mBlocked = true;
                    continue;
                }
                if (mPendingIdleHandlers == null) {
                    mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
                }
                mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
            }
            for (int i = 0; i < pendingIdleHandlerCount; i++) {
                final IdleHandler idler = mPendingIdleHandlers[i];
                mPendingIdleHandlers[i] = null; // release the reference to the handler
                boolean keep = false;
                try {
                    //执行 IdleHandler
                    //如果返回 false 的话说明之后不再需要执行，那就将其移除
                    keep = idler.queueIdle();
                } catch (Throwable t) {
                    Log.wtf(TAG, "IdleHandler threw exception", t);
                }
                if (!keep) {
                    synchronized (this) {
                        mIdleHandlers.remove(idler);
                    }
                }
            }
            ···
        }
    }

应用场景

Android里面有一个场景：

当从一个Activity启动另一个Activity时，Ams要先调用当前Activity的onPause()，然后再启动目标Activity，目标Activity启动后，要把原Activity完全覆盖掉，按照Activity的生命周期管理，原Activity要调用onStop()，但它是在什么时候调用的呢，就是在IdleHandler中调用的。为什么这样做呢，因为新Activity的显示非常重要，要保证它的优先处理，旧Activity要销毁了，已经不显示UI界面了，那就等到UI线程处于空闲期再处理。

另一个场景：
例如，ActivityThread 就向主线程 MessageQueue 添加了一个 GcIdler，用于在主线程空闲时尝试去执行 GC 操作

public final class ActivityThread extends ClientTransactionHandler {
    @UnsupportedAppUsage
    void scheduleGcIdler() {
        if (!mGcIdlerScheduled) {
            mGcIdlerScheduled = true;
            //添加 IdleHandler
            Looper.myQueue().addIdleHandler(mGcIdler);
        }
        mH.removeMessages(H.GC_WHEN_IDLE);
    }
    final class GcIdler implements MessageQueue.IdleHandler {
        @Override
        public final boolean queueIdle() {
            //尝试 GC
            doGcIfNeeded();
            purgePendingResources();
            return false;
        }
    }
}

自己App的场景

Android应用运行启动之后，一般要进行全局初始化、资源加载、UI显示等一系列的操作，显然此时会出现CPU使用一个高峰期，如果这些任务不加区分，一股脑的全部运行起来，势必影响到UI的显示。因此，可以对此进行流程优化，全力把保障UI线程的运行，把初始化、资源加载分为两部分，一部分是UI界面显示必需的，另一部分和初始化界面不相关的，在应用启动阶段只运行和UI相关的部分，其余部分等到高峰期过去之后再运行。

Looper.myQueue().addIdleHandler(new MessageQueue.IdleHandler() { 
    @Override public boolean queueIdle() { 
        initInBackground(); //后台运行的初始化任务在UI处于空闲时运行
        return false; 
    } 
});

8、做一个总结

再来总结下以上的所有内容

1. 每个 Handler 都会和一个 Looper 实例关联在一起，可以在初始化 Handler 时通过构造函数主动传入实例，否则就会默认使用和当前线程关联的 Looper 对象
2. 每个 Looper 都会和一个 MessageQueue 实例关联在一起，每个线程都需要通过调用 Looper.prepare()方法来初始化本线程独有的 Looper 实例，并通过调用Looper.loop()方法来使得本线程循环向 MessageQueue 取出消息并执行。Android 系统默认会为每个应用初始化和主线程关联的 Looper 对象，并且默认就开启了 loop 循环来处理主线程消息
3. MessageQueue 按照链表结构来保存 Message，执行时间早（即时间戳小）的 Message 会排在链表的头部，Looper 会循环从链表中取出 Message 并回调给 Handler，取值的过程可能会包含阻塞操作
4. Message、Handler、Looper、MessageQueue 这四者就构成了一个生产者和消费者模式。Message 相当于产品，MessageQueue 相当于传输管道，Handler 相当于生产者，Looper 相当于消费者
5. Handler 对于 Looper、Handler 对于 MessageQueue、Looper 对于 MessageQueue、Looper 对于 Thread ，这几个之间都是一一对应的关系，在关联后无法更改，但 Looper 对于 Handler、MessageQueue 对于 Handler 可以是一对多的关系
6. Handler 能用于更新 UI 包含了一个隐性的前提条件：Handler 与主线程 Looper 关联在了一起。在主线程中初始化的 Handler 会默认与主线程 Looper 关联在一起，所以其 handleMessage(Message msg) 方法就会由主线程来调用。在子线程初始化的 Handler 如果也想执行 UI 更新操作的话，则需要主动获取 mainLooper 来初始化 Handler
7. 对于我们自己在子线程中创建的 Looper，当不再需要的时候我们应该主动退出循环，否则子线程将一直无法得到释放。对于主线程 Loop 我们则不应该去主动退出，否则将导致应用崩溃
8. 我们可以通过向 MessageQueue 添加 IdleHandler 的方式，来实现在 Loop 线程处于空闲状态的时候执行一些优先级不高的任务。例如，假设我们有个需求是希望当主线程完成界面绘制等事件后再执行一些 UI 操作，那么就可以通过 IdleHandler 来实现，这可以避免拖慢用户看到首屏页面的速度

三、Handler 在系统中的应用

1、HandlerThread

HandlerThread 是 Android SDK 中和 Handler 在同个包下的一个类，从其名字就可以看出来它是一个线程，而且使用到了 Handler

其用法类似于以下代码。通过 HandlerThread 内部的 Looper 对象来初始化 Handler，同时在 Handler 中声明需要执行的耗时任务，主线程通过向 Handler 发送消息来触发 HandlerThread 去执行耗时任务

class MainActivity : AppCompatActivity() {
    private val handlerThread = HandlerThread("I am HandlerThread")
    private val handler by lazy {
        object : Handler(handlerThread.looper) {
            override fun handleMessage(msg: Message) {
                Thread.sleep(2000)
                Log.e("MainActivity", "这里是子线程，可以用来执行耗时任务：" + Thread.currentThread().name)
            }
        }
    }
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        btn_test.setOnClickListener {
            handler.sendEmptyMessage(1)
        }
        handlerThread.start()
    }
}

HandlerThread 的源码还是挺简单的，只有一百多行

HandlerThread 是 Thread 的子类，其作用就是为了用来执行耗时任务，其 run()方法会自动为自己创建一个 Looper 对象并保存到 mLooper，之后就主动开启消息循环，这样 HandlerThread 就会来循环处理 Message 了

public class HandlerThread extends Thread {
    //线程优先级
    int mPriority;
    //线程ID
    int mTid = -1;
    //当前线程持有的 Looper 对象
    Looper mLooper;
    private @Nullable Handler mHandler;
    public HandlerThread(String name) {
        super(name);
        mPriority = Process.THREAD_PRIORITY_DEFAULT;
    }
    public HandlerThread(String name, int priority) {
        super(name);
        mPriority = priority;
    }
    @Override
    public void run() {
        mTid = Process.myTid();
        //触发当前线程创建 Looper 对象
        Looper.prepare();
        synchronized (this) {
            //获取 Looper 对象
            mLooper = Looper.myLooper();
            //唤醒所有处于等待状态的线程
            notifyAll();
        }
        //设置线程优先级
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        //开启消息循环
        Looper.loop();
        mTid = -1;
    }
}

此外，HandlerThread 还包含一个getLooper()方法用于获取 Looper。当我们在外部调用handlerThread.start()启动线程后，由于其run()方法的执行时机依然是不确定的，所以 getLooper()方法就必须等到 Looper 初始化完毕后才能返回，否则就会由于wait()方法而一直阻塞等待。当run()方法初始化 Looper 完成后，就会调用notifyAll()来唤醒所有处于等待状态的线程。所以外部在使用 HandlerThread 前就记得必须先调用 start() 方法来启动 HandlerThread

    //获取与 HandlerThread 关联的 Looper 对象
    //因为 getLooper() 可能先于 run() 被执行
    //所以当 mLooper 为 null 时调用者线程就需要阻塞等待 Looper 对象创建完毕
    public Looper getLooper() {
        if (!isAlive()) {
            return null;
        }
        // If the thread has been started, wait until the looper has been created.
        synchronized (this) {
            while (isAlive() && mLooper == null) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }
        }
        return mLooper;
    }

HandlerThread 起到的作用就是方便了主线程和子线程之间的交互，主线程可以直接通过 Handler 来声明耗时任务并交由子线程来执行。使用 HandlerThread 也方便在多个线程间共享，主线程和其它子线程都可以向 HandlerThread 下发任务，且 HandlerThread 可以保证多个任务执行时的有序性

2、IntentService

IntentService 是系统提供的 Service 子类，用于在后台串行执行耗时任务，在处理完所有任务后会自动停止，不必来手动调用 stopSelf() 方法。而且由于IntentService 是四大组件之一，拥有较高的优先级，不易被系统杀死，因此适合用于执行一些高优先级的异步任务

Google 官方以前也推荐开发者使用 IntentService，但是在 Android 11 中已经被标记为废弃状态了，但这也不妨碍我们来了解下其实现原理

IntentService 内部依靠 HandlerThread 来实现，其 onCreate()方法会创建一个 HandlerThread，拿到 Looper 对象来初始化 ServiceHandler。ServiceHandler 会将其接受到的每个 Message 都转交由抽象方法 onHandleIntent来处理，子类就通过实现该方法来声明耗时任务

public abstract class IntentService extends Service {
    private volatile Looper mServiceLooper;
    @UnsupportedAppUsage
    private volatile ServiceHandler mServiceHandler;
    private final class ServiceHandler extends Handler {
        public ServiceHandler(Looper looper) {
            super(looper);
        }
        @Override
        public void handleMessage(Message msg) {
            onHandleIntent((Intent)msg.obj);
            stopSelf(msg.arg1);
        }
    }
    @Override
    public void onCreate() {
        super.onCreate();
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        //触发 HandlerThread 创建 Looper 对象
        thread.start();
        //获取 Looper 对象，构建可以向 HandlerThread 发送 Message 的 Handler
        mServiceLooper = thread.getLooper();
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }
    @WorkerThread
    protected abstract void onHandleIntent(@Nullable Intent intent);
}

每次 start IntentService 时，onStart()方法就会被调用，将 intent 和 startId 包装为一个 Message 对象后发送给mServiceHandler。需要特别注意的是 startId 这个参数，它用于唯一标识每次对 IntentService 发起的任务请求，每次回调 onStart() 方法时，startId 的值都是自动递增的。IntentService 不应该在处理完一个 Message 之后就立即停止 IntentService，因为此时 MessageQueue 中可能还有待处理的任务还未取出来，所以如果当调用 stopSelf(int)方法时传入的参数不等于当前最新的 startId 值的话，那么stopSelf(int) 方法就不会导致 IntentService 被停止，从而避免了将尚未处理的 Message 给遗漏了

    @Override
    public void onStart(@Nullable Intent intent, int startId) {
        Message msg = mServiceHandler.obtainMessage();
        msg.arg1 = startId;
        msg.obj = intent;
        mServiceHandler.sendMessage(msg);
    }
    @Override
    public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
        onStart(intent, startId);
        return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
    }

四、Handler 在三方库中的应用

1、EventBus

EventBus 的 Github 上有这么一句介绍：EventBus is a publish/subscribe event bus for Android and Java. 这说明了 EventBus 是普遍适用于 Java 环境的，只是对 Android 系统做了特殊的平台支持而已。EventBus 的四种消息发送策略包含了ThreadMode.MAIN 用于指定在主线程进行消息回调，其内部就是通过 Handler 来实现的

EventBusBuilder 会去尝试获取 MainLooper，如果拿得到的话就可以用来初始化 HandlerPoster，从而实现主线程回调

    MainThreadSupport getMainThreadSupport() {
        if (mainThreadSupport != null) {
            return mainThreadSupport;
        } else if (AndroidLogger.isAndroidLogAvailable()) {
            Object looperOrNull = getAndroidMainLooperOrNull();
            return looperOrNull == null ? null :
                    new MainThreadSupport.AndroidHandlerMainThreadSupport((Looper) looperOrNull);
        } else {
            return null;
        }
    }
    static Object getAndroidMainLooperOrNull() {
        try {
            return Looper.getMainLooper();
        } catch (RuntimeException e) {
            // Not really a functional Android (e.g. "Stub!" maven dependencies)
            return null;
        }
    }

public class HandlerPoster extends Handler implements Poster {
    protected HandlerPoster(EventBus eventBus, Looper looper, int maxMillisInsideHandleMessage) {
        super(looper);
        ···
    }
    ···
    @Override
    public void handleMessage(Message msg) {
        ···
    }
}

2、Retrofit

和 EventBus 一样，Retrofit 的内部实现也不需要依赖于 Android 平台，而是可以用于任意的 Java 客户端，Retrofit 只是对 Android 平台进行了特殊实现而已

在构建 Retrofit 对象的时候，我们可以选择传递一个 Platform 对象用于标记调用方所处的平台

public static final class Builder {
    private final Platform platform;
    Builder(Platform platform) {
      this.platform = platform;
    }
    ···
}