Handler机制及原理探究

Handler使用简单功能强大，常被用作线程间传递消息的组件，而且还可以用于跨进程。

消息机制背后有包括Looper ，MessageQueue管理和分发消息的实现，同时在Native层也单独实现了一套类似的机制，接收和处理Native层的消息。Java层和Native层的消息循环是独立运行的，彼此的Message并不会互通，Native使用epoll机制来实现监听及触发，并向JAVA层提供了接口。

这里从Java层开始深入探究下Handler和消息机制背后实现的原理。

---

初探Handler

本章只作为入口，先从宏观上去了解其中的架构，之后再做深入分析。

代码架构

Handler本身只负责发送和处理接收到的消息，其背后有一个消息循环为它管理和提供消息。
MessageQueue是管理着Message链表；而Looper是消息循环的主体，负责循环从MessageQueue中获取需要处理的新消息并向Handler输送。

其中MessageQueue有部分核心实现在native层（后续会讲到）。

MessageQueue.java
   private native static long nativeInit();
   private native static void nativeDestroy(long ptr);
   private native void nativePollOnce(long ptr, int timeoutMillis); /*non-static for callbacks*/
   private native static void nativeWake(long ptr);
   private native static boolean nativeIsPolling(long ptr);
   private native static void nativeSetFileDescriptorEvents(long ptr, int fd, int events);

native方法实现在JNI层的android_os_MessageQueue.cpp：

android_os_MessageQueue.cpp
static const JNINativeMethod gMessageQueueMethods[] = {
    /* name, signature, funcPtr */
    { "nativeInit", "()J", (void*)android_os_MessageQueue_nativeInit },
    { "nativeDestroy", "(J)V", (void*)android_os_MessageQueue_nativeDestroy },
    { "nativePollOnce", "(JI)V", (void*)android_os_MessageQueue_nativePollOnce },
    { "nativeWake", "(J)V", (void*)android_os_MessageQueue_nativeWake },
    { "nativeIsPolling", "(J)Z", (void*)android_os_MessageQueue_nativeIsPolling },
    { "nativeSetFileDescriptorEvents", "(JII)V",
            (void*)android_os_MessageQueue_nativeSetFileDescriptorEvents },
};

什么是Handler？

打开Handler.java，先看下googler留给开发者留的一段说明：

/**
 * A Handler allows you to send and process {@link Message} and Runnable
 * objects associated with a thread's {@link MessageQueue}.  Each Handler
 * instance is associated with a single thread and that thread's message
 * queue.  When you create a new Handler, it is bound to the thread /
 * message queue of the thread that is creating it -- from that point on,
 * it will deliver messages and runnables to that message queue and execute
 * them as they come out of the message queue.
 * 
 * <p>There are two main uses for a Handler: (1) to schedule messages and
 * runnables to be executed as some point in the future; and (2) to enqueue
 * an action to be performed on a different thread than your own.
 * 
 * <p>Scheduling messages is accomplished with the
 * {@link #post}, {@link #postAtTime(Runnable, long)},
 * {@link #postDelayed}, {@link #sendEmptyMessage},
 * {@link #sendMessage}, {@link #sendMessageAtTime}, and
 * {@link #sendMessageDelayed} methods.  The <em>post</em> versions allow
 * you to enqueue Runnable objects to be called by the message queue when
 * they are received; the <em>sendMessage</em> versions allow you to enqueue
 * a {@link Message} object containing a bundle of data that will be
 * processed by the Handler's {@link #handleMessage} method (requiring that
 * you implement a subclass of Handler).
 * 
 * <p>When posting or sending to a Handler, you can either
 * allow the item to be processed as soon as the message queue is ready
 * to do so, or specify a delay before it gets processed or absolute time for
 * it to be processed.  The latter two allow you to implement timeouts,
 * ticks, and other timing-based behavior.
 * 
 * <p>When a
 * process is created for your application, its main thread is dedicated to
 * running a message queue that takes care of managing the top-level
 * application objects (activities, broadcast receivers, etc) and any windows
 * they create.  You can create your own threads, and communicate back with
 * the main application thread through a Handler.  This is done by calling
 * the same <em>post</em> or <em>sendMessage</em> methods as before, but from
 * your new thread.  The given Runnable or Message will then be scheduled
 * in the Handler's message queue and processed when appropriate.
 */

既然决定来了就不能放过每个细节，记录下重点。
运作方式：
每一个Handler实例只与一个单独的Thread和这个Thread的MessageQueue关联；
当我们在Thread中创建一个新的Handler时，会绑定这个Thread和Thread的MessageQueue，之后Handler允许我们向MessageQueue发送Message和Runnable，并在消息出列时处理它们。

Handler的2个主要用途：
1. 让Message和Runnable可以延迟执行；
2. 在另外一个线程中执行处理。

用法：
通过Post开头和sendMessage开头的方法可以发送消息到MessageQueue。
1. post开头的方法可以向队列插入Runnable；
2. sendMessage开头的方法则用于来送Message，Message将在handleMessage方法中被处理。
3. post和send方法既可以让消息“实时”被处理（相对于延时），也可以设置特定的时延，延时去处理。

建议：
应用进程中的的主线程是专门用于管理顶层的数据的，例如activity/广播/窗口等，不宜处理其他我们定义的耗时操作，因此我们应该创建自己的工作线程，通过Handler来向线程的MessageQueue发送要执行的任务。

三个需要理解的问题

看完上面这段话，有3个疑问需要探究：
1. Handler如何与Thread关联？
2. Thread和MessageQueue的关系是？
3. MessageQueue如何运作？它如何管理Runnable和Message？

后面对这些问题一一破解。

---

从如何使用Handler开始

怎么样才能使Handler正常运作？

例子1——定义在子线程的Handler

public class MainActivity extends AppCompatActivity {
   

    Handler mHandler;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Log.i("handler.demo", "Main Thread:" + Thread.currentThread().toString());
        new MyThread().start();
        //确保Handler已经在子线程中实例化
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                Log.i("handler.demo", "Running in Thread:" + Thread.currentThread().toString());
            }
        });
    }

    class MyThrea