android消息机制1-整体概览

应用程序入口：

ActivityThread类中

public static void main(String[] args) {
  
  

    Looper.prepareMainLooper();

    ActivityThread thread = new ActivityThread();
    thread.attach(false);

    // End of event ActivityThreadMain.
 
    Looper.loop();

    throw new RuntimeException("Main thread loop unexpectedly exited");
}

可以知道，程序初始化就会在主线程预加载MainLooper

public static void prepareMainLooper() {
    prepare(false);
    ...
        sMainLooper = myLooper();
    }
}

private static void prepare(boolean quitAllowed) {
    sThreadLocal.set(new Looper(quitAllowed));
}

public static @Nullable Looper myLooper() {
    return sThreadLocal.get();
}

以上就是Looper.prepareMainLooper()的过程，可以看出先在ThreLocal准备Looper对象，然后get Looper对象，先设置后获取再使用，不会为null

额外提一下ThreadLocal是个什么类？

* Implements a thread-local storage, that is, a variable for which each thread
* has its own value. All threads share the same {@code ThreadLocal} object,
* but each sees a different value when accessing it, and changes made by one
* thread do not affect the other threads.

就是说作用范围线程域，同一进程中的所有线程共享这个对象，但是每个线程根据其映射的值又不同

举个栗子，月亮只有一个，每个人中秋晚上赏月看到的月亮都不同

然后Looper进行loop()

public static void loop() {
    final Looper me = myLooper();
   
    final MessageQueue queue = me.mQueue;

    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;
        }

        msg.target.dispatchMessage(msg);

        msg.recycleUnchecked();
    }
}

看loop的过程，先得到消息队列queue=me.mQueue,这个队列是什么时候初始化的呢

private Looper(boolean quitAllowed) {
    mQueue = new MessageQueue(quitAllowed);
    mThread = Thread.currentThread();
}

是在给ThreadLocal绑定Looper时候初始化的。

既然消息队列有了，那就一个一个开始取吧，永真循环就开始了

当取到了消息之后，Handler就会分发消息dispatchMessage(msg)

岔开说一下，msg.target就是发送该消息的Handler对象

每一个轮询出来的消息都会持有一个发送该消息的引用，因为入队列时就保证了target不为null

源码在Handler中如下

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
    msg.target = this;
    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis);
}

回归主线，Hander分发消息

public void dispatchMessage(Message msg) {
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        handleMessage(msg);
    }
}

如果没有msg的Runnable任务或者Handler的回调，那么就会调用handleMessage(msg),这个方法就是调用者实现。

至此消息机制的整体流程讲完了。

有几个问题还要讲下：

1，既然是Looper一直在死循环，为何不引起阻塞，对性能有何影响

答案是linux的管道通信机制