Android单线程模型
我们知道进程是cpu资源分配的最小单位，线程是cpu调度的最小单位。早期的操作系统里进程既是资源分配也是调度的最小单位，后来随着cpu速度越来越快，为了更合理的使用cpu，减少进程切换的开销，才将资源分配和调度分开，就有了线程。线程是建立在进程的基础上的一次程序运行单位。
当我们第一次打开一个App时，系统就会给这个App分配一个进程，并且启动一个main thread线程，主线程主要负责处理与UI相关的事件，如：用户的按键事件，用户接触屏幕的事件以及屏幕绘图事件，并把相关的事件分发到对应的组件进行处理。所以主线程通常又被叫做UI线程。
在开发Android 应用时必须遵守单线程模型的原则： Android UI操作并不是线程安全的并且这些操作必须在UI线程中执行。
疑问
既然UI操作只能在UI线程里更新，那么可不可以把所有操作都放在UI线程里面呢？答案是不可能的，可能会导致ANR。所以一些常用的耗时操作只能在非UI线程里执行，比如网络，数据库，IO操作等。那在非UI线程执行完后我们想把处理结果通知给UI线程怎么办，这就涉及到线程间通信的问题。
传统的Java线程间通信包括volatile，synchronized，CountDownLatch等不适合于Android，因为AndroidUI线程是消息驱动模式，主线程在启动时会初始化一个Looper，并调用loop()方法开启死循环，在循环里执行处理消息的操作。
大致流程图如下：
UML类图
流程讲解
接下来我们以handler的创建为起始点，结合源码开始讲解。
hander创建（UI线程中）
handler = new Handler();
查看构造函数：
public Handler() {
this(null, false);
}
这里可以传入两个参数，一个为callback，他是Handler的内部接口，里面只有一个方法：
public interface Callback {
/**
* @param msg A {@link android.os.Message Message} object
* @return True if no further handling is desired
*/
public boolean handleMessage(Message msg);
}
也就是我们初始化Handler的时候可以传入一个Callback，之后Looper会回调这个Callback。
另一个参数表示是否是异步消息
Handler.java
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;
}
可以看见这里面会获取Looper，如果Looper为空，则会报错；由于Handler实在主线程里面创建的，默认用的是主线程的Looper，而主线程的Looper实在ActivityThread的main方法中创建的。所以如果在其他线程创建Handler必须显示的创建Looper。
我们进入Looper.myLooper()方法里面看看
Handler.java
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();
}
ThreadLocal是一个类似于HashMap的数据结构，它主要是用于保存线程的局部变量，ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。
也就是myLooper()会获取当前线程的Looper，那么主线程的Looper实在哪创建的呢？答案是在ActivityThread中
ActivityThread.java
public static void main(String[] args) {
...
Looper.prepareMainLooper();
...
Looper.loop();
}
Looper.java
/**
* 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();
}
}
调用prepare方法
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));
}
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
所以就是在这创建完Looper的，并且创建想赢的MessageQueue，然后把Looper保存到ThreadLocal中
结论：一个线程对应一个Looper对应一个MessageQueue
发送消息
Handler创建完毕后，我们就可以发送消息了，发送消息有几种方式，如post(),sendMessage();最终都会调用handler的sendMessageAtTime()方法(post 的Runnnale也会包装成Message)
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);
}
mQueue就是在创建Handler时赋值的，它会调用MessageQueue的enqueueMessage方法
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
这里要注意的是把msg.target指向了自己，这是为了Looper处理完消息后回调自己的相关方法。
接下来进入MessageQueue里面
boolean enqueueMessage(Message msg, long when) {
...
//防止多个子线程同时发送消息，导致不可预知的错误
synchronized (this) {
...
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);
}
....
}
....
}
mMessages是当前Looper正在处理的消息，即消息队列的队头，赋值的地方是在next()方法里面；即如果当前队头的消息为空或者待入队的消息延时为0或者待入队的消息的延时小于队头的延时，则把待入队的消息插入到队的头部；
这可以看出MessageQueue是一个按when顺序排列的优先级队列，队头的when是最小；
同时加入之前是延迟消息，会阻塞当前队列，所以还需要唤醒
else里面会开启for循环，这个循环的目的是插入消息到链表的中间：如果插入消息到链表头部的条件不具备，则依次循环消息链表比较触发时间的长短，然后将消息插入到消息链表的合适位置。接着如果需要唤醒线程处理则调用C++中的nativeWake()函数。
这样handler插入消息的流程就完毕了
Looper消息循环
当消息队列中有消息的时候，Looper就会去取出消息并执行，具体在Looper的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;
...
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);
end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
...
msg.recycleUnchecked();
}
}
这里面主要就是从MessageQueue中取出Message执行，即调用queue.next()，然后handler的dispatchMessage()方法，前面提到过msg.target执行的就是我们的handler。然后回收message，可以复用；这也是为什么建议用Message.obtain()来生成message的原因。
接下来看MessageQueue的next方法
Message next() {
...
for (;;) {
...
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;
}
// Process the quit message now that all pending messages have been handled.
if (mQuitting) {
dispose();
return null;
}
// If first time idle, then get the number of idlers to run.
// Idle handles only run if the queue is empty or if the first message
// in the queue (possibly a barrier) is due to be handled in the future.
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);
}
}
...
}
nativePollOnce(ptr, nextPollTimeoutMillis);是一个native方法，它的作用是在native层阻塞，对用nativeWake()唤醒，接下通过do while循环在MessageQueue中找message，如果Handler传入了async参数为true，这里的msg.isAsynchronous()为true，循环退出，即找出第一个不为空的同步message或者异步message；
找到后会计算该message的执行时间是不是现在这个时间点，如果还没到它该执行的时间点，则计算剩余的时间 nextPollTimeoutMillis，否则的话该message就是我们要找的message，然后取出该message，并改变链表的指针。
值得一提的是MessageQueue有个有趣的接口IdleHandler，看名字就知道它是个空的handler，当MessageQueue中没有消息的时候，如果有IdleHandler，则会调用queueIdle()方法，关于它的用法之后我们会讲到。
Message走了一圈又回到了Handler
Message从子线程走到了主线程，走了一圈又回到了Handler
/**
* 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);
}
}
如果Message设置了回调方法的话，则回调该方法，这个是当我们调用handler.post(Runnable able)时设置的，即这个callback就是runnable，他会调用用runnable的run方法；
如果Message没设置回调，并且handler设置了callback，这个callback是在构造方法里面设置的，之前讲到过，然后回调callback的handleMessage()；
如果前两步都没设置回调，则会调用自身的handleMessage(msg)方法，这个就是我们熟悉的，经常复写的方法。
总结
终上所述，一个message从子线程走到了主线程，这其中都是Handler的功劳，handler负责发送消息入队，然后处理消息，这样完成了一个操作从子线程到主线程的切换，其本质就是把一个操作从子线程传递给主线程。关于子线程更新UI的相关有趣操作我们会在另外的文章里讲。
Tips1: handler在哪个线程创建，持有的就是哪个线程的Looper，MessageQueue。当然你也可以在构造函数中显示的指定哪个线程的Looper。比如主线程创建的默认是主线程的mainLooper。
Tips2: 子线程创建Handler，由于子线程没有自己的Looper，所以必须显示调用Looper.prepare()创建Looper，并且显示的调用Looper.loop()方法开启消息循环。
Tips3: handler的底层用的是Linux的管道通信，至于原因，我们之后再讲；
Message流向图
时序图
