在实际项目当中，一个很常见的需求场景就是在根据子线程当中的数据去更新ui。我们知道，android中ui是单线程模型的，就是只能在UI线程（也称为主线程）中更新ui。而一些耗时操作，比如数据库，网络请求，I／O等都是在其他线程中进行的，那么此时就需要在不同线程中进行通信了，而我们最常用的方式就是Handler。
常见的使用方式如下：
public class HandlerTestActivity extends AppCompatActivity {
public static final String TAG = "HandlerTestActivity";
private TextView displayTv;
private Handler mHandler = new Handler(){
@Override
public void handleMessage(Message msg) {
if (msg.what == 42){
displayTv.setText("" + msg.arg1);
}
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_handler_test);
displayTv = (TextView)findViewById(R.id.handlerDisplayTv);
new Thread(new Runnable() {
@Override
public void run() {
int count = 0;
while (true) {
try {
//模拟耗时操作
TimeUnit.MILLISECONDS.sleep(1000);
}catch (InterruptedException e){
}
Message msg = new Message();
msg.what = 42;
msg.arg1 = count++;
mHandler.sendMessage(msg);
}
}
}).start();
}
}
实际的效果图：
其实也很简单，就是 每间隔1秒钟，屏幕上的textview显示的数字增加1。
总结一下，Handler,Looper,MessageQueue,Message这些组成了android当中的异步消息处理机制。主要用于不同的线程之间通讯。（虽然我们最常用到的场景就是 发送消息来更新ui）。
而在android的官方sdk文档中，给出的官方demo其实是这样的。
class LooperThread extends Thread {
public Handler mHandler;
public void run() {
Looper.prepare();
mHandler = new Handler() {
public void handleMessage(Message msg) {
// process incoming messages here
}
};
Looper.loop();
}
}
它的基本原理如下。
1，在某个线程中。首先调用Looper.prepare()方法，来准备一个Looper实例，绑定到了该线程，并维护了一个消息队列（MessageQueue），MessageQueue它里面装的内容就是Message，然后调用 Looper.loop()，这是一个无限循环，它来取出消息队列当中的Message送到Handler进行处理。
2，我们new Handler（）过程中，来获得到该线程的Looper。然后在其他线程当中，可以调用Handler实例来发送消息（sendMessage方法等），发送的message被放到了MessageQueue中，然后在Handler所在的线程中，Handler实例再通过handleMessage（）等方法来处理 这个message，这样就实现了不同线程当中的通信。
所以问题的关键是 一个Handler实例所在的线程只有唯一的一个Looper来维持无限循环，并且它也维护了唯一的一个消息队列（MessageQueue）来传送Message（导入和取出）。
其实这个原理还是不复杂的，随便一本android入门书上也都会讲到这个问题，（并且肯定比我总结的要通俗易懂和严谨）。不过作为一个程序猿，不仅要知其然，更要知其所以然。深层次的理解了它的原理，不仅便于我们的记忆，也可以让我们使用起来更加得心应手。
所以下面，我就从源码的角度来分析这一过程，从子线程当中的sendMessage（）开始，然后又怎么在主线程当中handleMessage（）进行接收处理的。
首先来看 Handler.java
/**
* Default constructor associates this handler with the {@link Looper} for the
* current thread.
*
* If this thread does not have a looper, this handler won't be able to receive messages
* so an exception is thrown.
*/
public Handler() {
this(null, false);
} public Handler(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 that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
当然，Handler的构造方法有好几个。不过我们先沿着主线去分析。
在这个构造方法中，最重要的是这两句。
mLooper = Looper.myLooper();
mQueue = mLooper.mQueue;
这两句话，说明我们在new Handler时，该线程必须准备好了一个 Looper以及MessageQueue。
然后我们再来看一下Looper.java当中的代码。
// sThreadLocal.get() will return null unless you've called prepare().
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>(); final MessageQueue mQueue;
final Thread mThread; private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
} public static @Nullable Looper myLooper() {
return sThreadLocal.get();
} 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的唯一一个构造方法是private的，所以我们要想得到Looper，那就只能通过prepare（）方法了，而在prepare（）方法中，注意那句“throw new RuntimeException("Only one Looper may be created per thread")”，这就保证了我们的Looper是唯一的，而通过Handler的构造方法的 “throw new RuntimeException("Can't create handler inside thread that has not called Looper.prepare()")”。我们也能保证在使用 Handler之前，必须已经调用了 Looper.prepare()来初始化这个唯一的Looper。
而关于这个存储Looper的ThreadLocal对象，其实是一个线程内部的数据存储类，它最大的特点是作用域是限定在该线程内的，也就是说，当它存储数据后（set方法）。只能在该线程内才能获取到数据。 其他线程调用get方法得到的其实会是null（也就是无法得到对应数据）。当然，它内部有一套相应的机制和算法来保证它的作用域是线程内的。
那么从这些代码当中，我们已经明白了，当我们在new Handler（）时，必须已经 初始化了唯一的一个Looper和MessageQueue了。
这里插一个问题。我们一直在口口声声的说，在new Handler之前，我们要调用 Looper.prepare（）来执行必要的初始化，可是在我们的第一个HandlerTestActivity demo中，根本没调用 这个方法啊。这个原因是因为在UI线程启动时，在ActivityThread中已经帮我们调用过 Looper.prepareMainLooper()方法了（ActivityThread也调用了Looper.loop()）。
/**
* Initialize the current thread as a looper, marking it as an
* application's main looper. The main looper for your application
* is created by the Android environment, so you should never need
* to call this function yourself. See also: {@link #prepare()}
*/
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
所以我们在 HandlerTestActivity中，不需要调用Looper.prepare（）方法了。而在官方的LooperThread demo中，因为不是在ui线程。那就只要你自己来调用 Looper.prepare()和Looper.loop()了.
既然Handler，Looper和MessageQueue我们已经都得到实例对象了，那么下面看看它的发送消息的过程。
/**
* Pushes a message onto the end of the message queue after all pending messages
* before the current time. It will be received in {@link #handleMessage},
* in the thread attached to this handler.
*
*/
public final boolean sendMessage(Message msg)
{
return sendMessageDelayed(msg, 0);
} /**
* Enqueue a message into the message queue after all pending messages
* before (current time + delayMillis). You will receive it in
* {@link #handleMessage}, in the thread attached to this handler.
*/
public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
} /**
* Enqueue a message into the message queue after all pending messages
* before the absolute time (in milliseconds) <var>uptimeMillis</var>.
* <b>The time-base is {@link android.os.SystemClock#uptimeMillis}.</b>
* Time spent in deep sleep will add an additional delay to execution.
* You will receive it in {@link #handleMessage}, in the thread attached
* to this handler.
* */
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);
}
通过代码可以看出，几经周折，其实调用的是 enqueueMessage(queue, msg, uptimeMillis)方法，这个方法就是重中之重了。（Handler的sendMessage的方法有几个，但是归根到底，最后还是 调用enqueueMessage方法来进行入队操作）。
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
通过代码可以看出来，Looper的enqueueMessage方法最后调用的还是 queue.enqueueMessage方法，也就是MessageQueue本身来进行入队操作。不过在这个方法中，我们还有一句要注意的代码，那就是
msg.target = this;通过这句代码，来把message的 target对象来变成 Handler本身了。这句代码在后面的处理流程中，是有重要作用的。
那么现在，我们就看看 MessageQueue的 enqueueMessage（）方法。
boolean enqueueMessage(Message msg, long when) {
if (msg.target == null) {
throw new IllegalArgumentException("Message must have a target.");
}
if (msg.isInUse()) {
throw new IllegalStateException(msg + " This message is already in use.");
}
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;
}
msg.markInUse();
msg.when = when;
Message p = mMessages;
boolean needWake;
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 {
// Inserted within the middle of the queue. Usually we don't have to wake
// up the event queue unless there is a barrier at the head of the queue
// and the message is the earliest asynchronous message in the queue.
needWake = mBlocked && p.target == null && msg.isAsynchronous();
Message prev;
for (;;) {
prev = p;
p = p.next;
if (p == null || when < p.when) {
break;
}
if (needWake && p.isAsynchronous()) {
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队列的方式是通过链表来实现的。
至于为什么插入的顺序是按照时间来的，因为我们在使用Handler来发送message时，有几个方法本来就是有个延迟时间的。（比如sendMessageDelayed(Message, long)等，默认的发送时间就是当前时间），并且在Message对象中，也有when属性来保存这个时间的。
不过这里的这个时间戳取的是 手机自开机之后的时间，而不是我们经常说的linux那个源自1970年的那个时间。
我们的代码看到这里，其实就应该告一段落了，那就是 我们通过Handler来发送的Message，已经被送入到MessageQuequ了。消息已经在消息队列了。那么怎么取出来进行处理呢。
我们在最初分析原理的时候就说过，Looper.loop（）中维持了一个无限循环，
看一下代码：
/**
* 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.");
}
final MessageQueue queue = me.mQueue; // Make sure the identity of this thread is that of the local process,
// and keep track of what that identity token actually is.
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity(); for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
} //省略一些其他代码
try {
msg.target.dispatchMessage(msg);
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
} if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
} //省略一些其他代码 msg.recycleUnchecked();
}
}
在这个代码当中，可以看到的确是维持了一个死循环，而这个死循环当中， 就是通过 queue.next() 从MessageQueue中取出message，并且如果没有数据的话，就会被阻塞。MessageQueue对象的next（）方法这里就不贴出来了，就是一个出队操作（根据message的when属性，当时间到了，就返回对象，并从队列中删除），。
可是取出来的message数据，这里怎么做处理呢。关键是这一句 msg.target.dispatchMessage(msg)，
别忘记了我们前面分析时，在message入队之前的一句代码 msg.target = this。所以 这里的 msg.target.dispatchMessage(msg)代码说白了还是在这个Handler的dispatchMessage（）来分发处理的message。
/**
* Handle system messages here.
*/
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
} /**
* Subclasses must implement this to receive messages.
*/
public void handleMessage(Message msg) {
}
在dispatchMessage方法中，经过两个if判断，最终message的处理，落到了 handleMessage（）方法，至于handleMessage（）方法，是个空方法，看看方法前面的注释，这个时候就应该恍然大悟了。
我们在 最初的 demo中的处理方式，不就是重写的 handleMessage方法嘛。。。
所以在这里，这个过程算是比较清晰了，Handler对象（在其他线程中）发送的message，被放入了 MessageQueue中，然后通过Looper的无限循环，最后又被取出到Handler所处的线程中进行了处理。
另外，除了我们传统Handler的sendMessage（）方法外，还有一种方法来使用Handler。
public class HandlerTest_2_Activity extends AppCompatActivity {
public static final String TAG = "HandlerTest_2_Activity";
private TextView displayTv;
private Handler mHandler;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_handler_test);
displayTv = (TextView) findViewById(R.id.handlerDisplayTv);
mHandler = new Handler();
new MyThread("子线程").start();
}
class MyThread extends Thread{
public MyThread(String name) {
super(name);
}
@Override
public void run() {
super.run();
mHandler.post(new Runnable() {
@Override
public void run() {
//操作UI
displayTv.setText("operation from " + Thread.currentThread().getName());
}
});
}
}
}
我们在 MyThread子线程当中，可以直接使用 mHandler.post方法来传递任务到ui线程中进行相关操作。（Thread才是线程，Runnable只是任务，如果不明白这一点的，可以看一下我前面写的几篇多线程的文章）。
我们也分析一下相关的代码：
/**
* Causes the Runnable r to be added to the message queue.
* The runnable will be run on the thread to which this handler is
* attached.
*/
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
} private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
看到 sendMessageDelayed（）方法，我们就很熟悉了，其实 还是老一套，将message发送到 队列中，不过 getPostMessage（）方法是什么呢？
代码就几行，将Runnable包装成Message。并且m.callback = r； 而关于Message，我们可以new，也可以使用obtain方法。后者效率更好一些，因为系统会维护一个Message池进行复用。
不要忘记了我们的dispatchMessage（）方法。
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
private static void handleCallback(Message message) {
message.callback.run();
}
此时再读读if判断的第一句，msg.callback是什么，不就是post中传递进去的 Runnable嘛，而这里回调的 handleCallback（）方法，转了一圈，最后还是回调到了 Runnable的run（）方法了。
所以使用Handler.post(Runnable)算是一种简写了。
不过在dispatchMessage（）方法中，还有这样一句判断，mCallback != null ，其实是这样的。
/**
* Callback interface you can use when instantiating a Handler to avoid
* having to implement your own subclass of Handler.
*
*/
public interface Callback {
public boolean handleMessage(Message msg);
}
public Handler(Callback callback) {
this(callback, false);
}
所以说，处理Message的方式不只一种。
写完这些，Handler这种消息处理机制已经从源码角度分析ok了。理解了原理，今后使用起来才更加的得心应手。原理其实不算复杂，但是真正的细节问题其实也有很多。这篇文章呢，也是我写的第一篇关于分析源码的文章，在这里呢，也给自己立个flag，希望今后能写更多的分析源码的文章。
---
github: https://github.com/yaowen369