涉及到的类：
ActvityThread，Handler，Looper，HandlerActionQuenue，ThreadLocal
ActvityThread
先从ActivtiyThread的main()函数入口分析
public static void main(String[] args) {
//内部首先Looper.prepare()创建Looper并初始化Looper持有的消息队列 MessageQueue
//(如果你抛出过这样的异常Can't create handler inside thread that has not called Looper.prepare()就知道prepare()很重要)
//创建好后将Looper保存到ThreadLocal中方便Handler直接获取。
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
//返回的是mH
sMainThreadHandler = thread.getHandler();
}
//--->开启循环
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
sMainThreadHandler ===>（即名为H的继承自Handler的对项，在ActivityThread初始化时，final H mH = new H()初始化）则作用通过binder线程向H发送消息即可，比如发送 H.LAUNCH_ACTIVITY 消息就是通知主线程调用Activity.onCreate() 。当然啦不是直接调用，H收到消息后会进行一系列复杂的函数调用最终调用到Activity.onCreate()。
补充：
ActivityThread 通过 ApplicationThread 和 AMS 进行进程间通讯，AMS 以进程间通信的方式完成 ActivityThread 的请求后会回调 ApplicationThread 中的 Binder 方法，然后 ApplicationThread 会向 H 发送消息，H 收到消息后会将 ApplicationThread 中的逻辑切换到 ActivityThread 中去执行，即切换到主线程中去执行，这个过程就是主线程的消息循环模型。
Looper.loop(); ====>从MessageQueue里面取消息并调用handler的 dispatchMessage(msg) 方法处理消息。如果MessageQueue里没有消息，循环就会阻塞进入休眠状态，等有消息的时候被唤醒处理消息。
此处我们来回答一个问题:
Android中为什么主线程不会因为Looper.loop()里的死循环卡死？
该循环有阻塞机制，所以死循环并不会一直执行。相反的，大部分时间是没有消息的，所以主线程大多数时候都是处于休眠状态，也就不会消耗太多的CPU资源导致卡死。
Message msg = queue.next(); // might block if(msg == null) {
// No message indicates that the message queue is quitting.
return;
}
1.阻塞的原理是使用Linux的管道机制实现的
2.主线程没有消息处理时阻塞在管道的读端
3.binder线程会往主线程消息队列里添加消息，然后往管道写端写一个字节，这样就能唤醒主线程从管道读端返回，也就是说looper循环里queue.next()会调用返回...
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;
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
//省略N行代码
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
final long end;
try {
msg.target.dispatchMessage(msg);
end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
msg.recycleUnchecked();
}
}
1.final Looper me = myLooper()--->获取主线程的Looper对象
2.MessageQueue queue = me.mQueue--->获取Looper中的消息队列
3.for (;;) {} ---->死循环，不断queue中取出message，处理msg.target.dispatchMessage(msg)
Handler类
先看Handler的构造方法
public Handler(Callback callback, boolean async) {
if (FIND_POTENTIAL_LEAKS) {
final Class<? extends Handler> klass = getClass();
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;
}
new Handler()的时候，Handler构造方法中获取Looper并且拿到Looper的MessageQueue对象。然后Handler内部就可以直接往MessageQueue里面插入消息了，插入消息即发送消息，这时候有消息了就会唤醒Looper循环去处理消息。处理消息就是调用dispatchMessage(msg) 方法，最终调用到我们重写的Handler的handleMessage()方法。
mLooper = Looper.myLooper(); ====>获取hander所在线程的Looper，不一定是MainLooper。
调用了ThreadLocal内的方法，这里存储了looper。后面讲ThreadLocal内的方法再展开
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
sendMessage、sendMessageDelayed等等方法，最终几乎调用
sendMessageAtTime(Message msg, long uptimeMillis)。
//获取消息队列，插入消息
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);
}
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
//发送消息的时候把自己封装到消息里的。
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
//向queue插入一条消息，loop循环的时候，取出其中的消息，并根据target，分发给相应的hanlder处理
return queue.enqueueMessage(msg, uptimeMillis);
}
ThreadLocal
public T get() {
//获取当前的thread
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
//取出它的table数组，并找出hreadLocal的reference对象在table数组中的位置，
//然后table数组中的下一个位置所存储的数据就是ThreadLocal的值。
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}
相对应的还有一个set()
public void set(T value) {
//获取当前thread
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
// 内部维护一个table数组，存储Thread的引用
map.set(this, value);
else
createMap(t, value);
}
