Android的消息机制

待我称王封你为后i 2022-07-13 11:17 118阅读 0赞

[Android][]的消息机制主要就是指Handler的运行机制，而Handler的运行需要Looper和MessageQueue的支撑，下面会详细的介绍整个过程

**写在前面：**

Handler：主要作用是将一个任务切换到某个指定的线程中去执行，它的创建需要有Looper如果没有则抛出异常，下面是源码

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** Handler(Callback callback, **boolean** async) \{  
2.      ......  
3.      mLooper = Looper.myLooper();  
4.      **if** (mLooper == **null**) \{  
5.          **throw** **new** RuntimeException(  
6.              "Can't create handler inside thread that has not called Looper.prepare()");  
7.      \}  
8.  \}  
9.

**Looper：**每个线程只能有一个Looper对象，可以没有，线程默认是没有Looper对象的，但是Activity的主线程（ActivityThread）被创建时会初始化Looper，在ActivityThread的main方法中通过Looper.preapareMainLooper()创建主线程的Looper，在handler运行机制中主要用到了loop方法去开启消息循环，后面会说到主要的工作内容

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **static** **void** main(String\[\] args) \{  
2.         
3.  ...  
4.       Looper.prepareMainLooper();  
5.       ActivityThread thread = **new** ActivityThread();  
6.       thread.attach(**false**);  
7.  ...  
8.       Looper.loop();  
9.  ...  
10.  \}

Looper.preapareMainLooper()

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **static** **void** prepareMainLooper() \{  
2.       prepare(**false**);  
3.       **synchronized** (Looper.**class**) \{  
4.           **if** (sMainLooper != **null**) \{  
5.               **throw** **new** IllegalStateException("The main Looper has already been prepared.");  
6.           \}  
7.           sMainLooper = myLooper();  
8.       \}  
9.   \}

**\[java\]**  [view plain][]   [copy][view plain]

1.  **private** **static** **void** prepare(**boolean** quitAllowed) \{  
2.      **if** (sThreadLocal.get() != **null**) \{  
3.          **throw** **new** RuntimeException("Only one Looper may be created per thread");  
4.      \}  
5.      sThreadLocal.set(**new** Looper(quitAllowed));  
6.  \}

sThreadLocal就是一个ThreadLocal，ThreadLoca是 线程本地储存，是一种自动化机制，可以为每个不同的线程都创建不同的储存，

关于ActivityThrad涉及到Activity的创建和启动，只要知道一句话即可**ActivityThread中performLaunchActivity方法完成最终的Activity的对象创建和启动，ActivityThread的main方法中初始化了Looper且调用了Looper.loop（）**

**MessageQueue：**消息队列，在Looper的构造函数中被创建，内部实现是一个单链表，主要用到的有enqueueMessage（添加消息）和next方法（获取下一条消息），其中**next方法是一个死循环**，如果MessageQueue中没有消息则进入阻塞

上面那么多总结起来其实就是一句话**一个Handler需要Looper才能创建，一个Looper可以对应多个Handler，一个线程只能有一个Looper，通过ThreadLocal可以获取线程的Looper对象，一个Looper对应一个MessageQueue因为MessageQueue是在Looper的构造函数中创建的，在Handler内部会调用Looper.mQueue()方法获取MessageQueue**

**整个过程：**

通过Looper创建Handler对象（对于非主线程需要使用Looper.prepare创建Looper对象，并通过Looper.loop开启消息循环，在主线程（ActivityThread）的main方法中这些都已经完成），在Looper的构造函数中会创建MessageQueue， [view plain][] [ copy][view plain]

1.  **private** Looper(**boolean** quitAllowed) \{  
2.          mQueue = **new** MessageQueue(quitAllowed);  
3.          mThread = Thread.currentThread();  
4.      \}

这时Handler、MessageQueue、Looper三者都有了，handler通过sendMessage方法发送message，在sendMessage方法内部会调用MessageQueue的enqueue方法将message加入到MessageQueue中，  [copy][view plain]

1.  **public** **final** **boolean** sendMessageAtFrontOfQueue(Message msg) \{  
2.          MessageQueue queue = mQueue;  
3.          **if** (queue == **null**) \{  
4.              RuntimeException e = **new** RuntimeException(  
5.                  **this** + " sendMessageAtTime() called with no mQueue");  
6.              Log.w("Looper", e.getMessage(), e);  
7.              **return** **false**;  
8.          \}  
9.          **return** enqueueMessage(queue, msg, 0);  
10.     \}

[copy][view plain]

1.  **private** **boolean** enqueueMessage(MessageQueue queue, Message msg, **long** uptimeMillis) \{  
2.         msg.target = **this**;  
3.         **if** (mAsynchronous) \{  
4.             msg.setAsynchronous(**true**);  
5.         \}  
6.         **return** queue.enqueueMessage(msg, uptimeMillis);  
7.     \}

上面的mQueue通过Looper.mQueue获取，而Looper则是通过ThreadLocal的get方法获取

同时Looper.loop方法内部是一个死循环会不断的调用MessageQueue的next方法，除非MessageQueue的next方法返回null则Looper会终止，  [copy][view plain]

1.  **public** **static** **void** loop() \{  
2.          ....  
3.          **for** (;;) \{ //死循环  
4.              Message msg = queue.next(); // might block  
5.              **if** (msg == **null**) \{  
6.                  // No message indicates that the message queue is quitting.  
7.                  **return**;  
8.              \}  
9.  ......  
10.             msg.target.dispatchMessage(msg);//msg.target就是looper对应handler  
11.   
12.          .....  
13.         \}  
14.     \}

但是MessageQueue的next方法内部也是一个死循环如果MessageQueue内部没有message了会阻塞，这里先放一放，  [copy][view plain]

1.  Message next() \{  
2.          ...  
3.          **for** (;;) \{ //死循环  
4.                
5.   .....  
6.  //从MessageQueue中获取message        [copy][view plain]

1.  ....  
2.                  // Process the quit message now that all pending messages have been handled.  
3.                  **if** (mQuitting) \{  
4.                      dispose();  
5.                      **return** **null**;  
6.                  \}  
7.    
8.                 .....  
9.          \}  
10.     \}

接着看Looper.loop方法剩下的内容，MessageQueue的next方法取出了一个message，这时候会调用msg.target.dispatchMessage(msg);而msg.target就是当前Looper对应的Handler，即handler.dispatchMessage(msg)会被调用，  [copy][view plain]

1.  msg.target.dispatchMessage(msg);//msg.target就是looper对应handler

而在handler.dispatchMessage(msg)方法内部会调用handleMessage（msg）方法，  [copy][view plain]

1.  **public** **void** dispatchMessage(Message msg) \{  
2.      **if** (msg.callback != **null**) \{  
3.          handleCallback(msg);  
4.      \} **else** \{  
5.          **if** (mCallback != **null**) \{  
6.              **if** (mCallback.handleMessage(msg)) \{  
7.                  **return**;  
8.              \}  
9.          \}  
10.         handleMessage(msg);  
11.     \}  
12. \}

上面说到Looper.loop方法内部的死循环只有在MessageQueue的next方法返回null时才会终止，如果才能让next方法返回null呢？调用Looper的quit或者quitSafely方法，  [copy][view plain]

1.  **public** **void** quit() \{  
2.          mQueue.quit(**false**);//mQueue就是MessageQueue  
3.      \}  [copy][view plain]

1.  **public** **void** quitSafely() \{  
2.         mQueue.quit(**true**);  
3.     \}

在这两个方法内部会调用MessageQueue的quit方法， 在MessageQueue的 quit方法的内部会将一个成员变量mQuitting设置为true，  [copy][view plain]

1.  **void** quit(**boolean** safe) \{  
2.          **if** (!mQuitAllowed) \{  
3.              **throw** **new** RuntimeException("Main thread not allowed to quit.");  
4.          \}  
5.    
6.          **synchronized** (**this**) \{  
7.              **if** (mQuitting) \{  
8.                  **return**;  
9.              \}  
10.             mQuitting = **true**;  
11.   
12.             **if** (safe) \{  
13.                 removeAllFutureMessagesLocked();  
14.             \} **else** \{  
15.                 removeAllMessagesLocked();  
16.             \}  
17.   
18.             // We can assume mPtr != 0 because mQuitting was previously false.  
19.             nativeWake(mPtr);  
20.         \}  
21.     \}

而在MessageQueue的next方法中有这样一段代码，如果mQuitting为true则返回null，此时Looper就停止了  [copy][view plain]

1.  // Process the quit message now that all pending messages have been handled.  
2.                  **if** (mQuitting) \{  
3.                      dispose();  
4.                      **return** **null**;  
5.                  \}

到这里可能还是有疑惑，如果我的主线程中不创建handler那主线程的MessageQueue不就是空的吗？当然不是，主线程的循环开始以后还需要一个Handler和主线程的MessageQueue进行交互（比如启动一个activity），这个Handler就是ActivityThread.H（ActivityThread的内部类），H的内部定义了一组消息内息，主要是四大组件的启动和停止等过程，ActivityThread通过ApplicationThread（ActivityThread的内部类）和AMS（ActivityManagerService）进行进程通信（比如Activity的启动所需要的信息等等），AMS以进程间通信的方式完成ActivityThread的请求后回调ApplicationThread中的Binder方法，然后ApplicationThread向H发送消息，然后H将ApplicationThread中的逻辑切换到ActivityThread中去执行

**一个小例子：**

Toast基本都用过，在主线程中使用没什么问题，但是如果**在子线程中使用Toast就会报异常**，大致内容就是缺少Looper，这是因为在Toast的内部有两类IPC过程，一类是Toast访问NotificationManagerService，第二类就是NotificationManagerService回调Toast里的TN接口达到Toast的显示和隐藏的效果，但是TN是运行在Binder线程池中的，所以需要借助Handler将其切换到当前线程，由于子线程默认是没有Looper的因此就无法创建Handler，就会报错，解决办法就是使用Looper.prepare()创建Looper，使用Looper.loop开启消息循环，将Toast包裹在两个方法中间即可，同时要记得使用完以后要调用Looper的quit方法终止消息循环，否则这个子线程就会一直处于等待状态

[Android]: http://lib.csdn.net/base/android
[view plain]: http://blog.csdn.net/fuckluy/article/details/54144017#