从源码分析Android消息机制

涉及到的类：
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 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);
    }