学步园

官方文档：

A Handler allows you to send and process Message and
Runnable objects associated with a thread's 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.

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.

Scheduling messages is accomplished with the post(Runnable),postAtTime(Runnable,long),postDelayed(Runnable,long),sendEmptyMessage(int),sendMessage(Message),sendMessageAtTime(Message,long),and sendMessageDelayed(Message,long) methods.
The post versions allow you to enqueue Runnable objects to be called by the message queue when they are received; the sendMessage versions allow you to enqueue a Message object
containing a bundle of data that will be processed by the Handler's handleMessage(Message) method
(requiring that you implement a subclass of Handler).

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.

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 post or sendMessage 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源代码的解析：

Handler类的全局变量：

1. final MessageQueue mQueue;  
2.     final Looper mLooper;  
3.     final Callback mCallback;  
4.     IMessenger mMessenger;  

这些全局变量都会在Handler的构造函数中进行赋值：

1.   /** 
2.      * Default constructor associates this handler with the queue for the 
3.      * current thread. 
4.      * If there isn't one, this handler won't be able to receive messages. 
5.      * 这是默认的构造方法，Handler是和当前线程的队列关联在一起的，如果队列不存在，那么Handler就不能接收消息。
6.      */  
7.     public Handler() {  
8.         if (FIND_POTENTIAL_LEAKS) {  
9.             final Class<? extends Handler> klass = getClass();  
10.             if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&  
11.                     (klass.getModifiers() & Modifier.STATIC) == 0) {  
12.                 Log.w(TAG, "The following Handler class should be static or leaks might occur: " +  
13.                     klass.getCanonicalName());  
14.             }  
15.         }  
16.   
17.   
18.         mLooper = Looper.myLooper();  
19.         if (mLooper == null) {  
20.             throw new RuntimeException(  
21.                 "Can't create handler inside thread that has not called Looper.prepare()");  
22.         }  
23.         mQueue = mLooper.mQueue;  
24.         mCallback = null;  
25.     }  
26.   
27.   
28.     /** 
29.      * Constructor associates this handler with the queue for the 
30.      * current thread and takes a callback interface in which you can handle 
31.      * messages. 
32.      * 这个构造函数需要传入一个callback接口，用于处理Handler传递的Message
33.      */  
34.     public Handler(Callback callback) {  
35.         if (FIND_POTENTIAL_LEAKS) {  
36.             final Class<? extends Handler> klass = getClass();  
37.             if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&  
38.                     (klass.getModifiers() & Modifier.STATIC) == 0) {  
39.                 Log.w(TAG, "The following Handler class should be static or leaks might occur: " +  
40.                     klass.getCanonicalName());  
41.             }  
42.         }  
43.   
44.   
45.         mLooper = Looper.myLooper();  
46.         if (mLooper == null) {  
47.             throw new RuntimeException(  
48.                 "Can't create handler inside thread that has not called Looper.prepare()");  
49.         }  
50.         mQueue = mLooper.mQueue;  
51.         mCallback = callback;  
52.     }  
53.   
54.   
55.     /** 
56.      * Use the provided queue instead of the default one. 
57.      * 使用提供的队列来代替默认的队列
58.      */  
59.     public Handler(Looper looper) {  
60.         mLooper = looper;  
61.         mQueue = looper.mQueue;  
62.         mCallback = null;  
63.     }  
64.   
65.   
66.     /** 
67.      * Use the provided queue instead of the default one and take a callback 
68.      * interface in which to handle messages.
69.      *使用提供的队列来代替默认的队列，并传入一个callback接口用于处理消息 
70.      */  
71.     public Handler(Looper looper, Callback callback) {  
72.         mLooper = looper;  
73.         mQueue = looper.mQueue;  
74.         mCallback = callback;  
75.     }  

这里有个 FIND_POTENTIAL_LEAKS参数：找到潜在的泄露。看下注释：

设置这个标记为true来检测不是静态的匿名,本地或成员类继承Handler类。这些类型的类可以带来潜在的泄漏。在Handler的构造方法里面使用到了这个参数，目的就如上所述：

接着下面就是Callback接口：

当你实例化一个Handler的时候可以使用Callback接口来避免写自定义的Handler子类。这里的机制类似与Thread与runable接口的关系。

在Handler里面，子类要处理消息的话必须重写handleMessage()这个方法，因为在handler里面它是个空方法：

再来看一下：dispatchMessage()这个方法：

用于传递系统消息。当message的callback不为空的时候，调用handleCallback方法，如下：

getMessageName()方法：

我们从源码中结合注释，返回传入message的name值，默认的实现是如火message.callback不为空，就返回callback的类名，或者返回一个16进制的message的what值。

obtainMessage()方法：

从一个全局消息池里面获取一个新的Message。在Message池中检索是否存在与handler实例对应的message比创建一个新的Message更高效。如果你不想创建新Message，就是用Message.obtain方法代替。

下面是几个obtainMessage的重载方法：

和上面相同，只是参数不同，为返回的Message的一些属性赋值。

在往下就是post（）方法了：

把传入的Runnable对象r加入到Message队列中，这个runnable对象将在handler关联的线程中执行。如果runnable对象被正确执行返回true，如果looper遍历消息队列时退出，则返回false。在这个方法中，主要是调用了sendMessageDelayed方法。在下面会有相应的分析。

接下来，看一下其他有关post的方法：

postAtTime在指定时间uptimeMillis把runnable插入到队列中去，另一个postAtTime方法又加了一个Object类型的token，在下面的sendMessageAtTime中具体分析。postDelayed在延迟delayMillis时间后插入队列。postAtFrontOfQueue把Runnable插入到队首，下一次轮询就会被执行。

下面是从队列中删除对应的runable：

下面就是重头戏SendMessage：

把一个消息插入到当前所有正在等待执行的消息的后面。它会在当前线程所关联的handler的handleMessage方法中被处理。我们看到这个方法主要是调用了sendMessageDelayed方法（延迟0秒发送消息）：

这个方法主要是在delayMillis时间后发送消息。调用的是467行的sendMessageAtTime方法：

这个方法才是真正执行插入到队列的操作，把message插入到消息队列中。

发送消息，均是调用sendMessageAtTime方法：

发送空消息，使用Message.obtain()方法获得一个Message（上面已经讲道这个方法）进行发送。

sendMessageAtFrotOfQueue：

把一个消息插入到message queue的队首。但是我们注意到在SendMessageAtTime中插入队列代码：

在uptimeMillis时间后插入到队列，而在sendMessageAtFrotOfQueue中插入队列代码：

按照字面意思理解，就是立即插入队列，但是立刻插入队列也不能实现插到队首。那到底是如何实现的哪？这一点，将在MessageQueue源码分析中揭晓。

从消息队列中删除对应的消息：

检查消息队列中是否存在相对应的消息：

获取当前looper：

往下，dump方法，从字面意思上理解：转储，具体作用，还不太了解，将在Looper源码解析中分析下。

获取当前Messenger：

关于Messenger信使类，请关注以后源码分析。

将一个Runnable封装成一个Message。

getPostMessage这个方法在上面所说的post系列方法中，被广泛使用。

处理message里面的runnable消息，直接调用了run方法。