异步消息处理机制.docx
《异步消息处理机制.docx》由会员分享，可在线阅读，更多相关《异步消息处理机制.docx（16页珍藏版）》请在冰豆网上搜索。
异步消息处理机制
Android异步消息处理机制完全解析，带你从源码的角度彻底理解
之前也是由于周末通宵看TI3比赛，一直没找到时间写博客，导致已经有好久没更新了。
惭愧！
后面还会恢复进度，尽量保证每周都写吧。
这里也是先恭喜一下来自瑞典的Alliance战队夺得了TI3的冠军，希望明年中国战队能够虎起！
开始进入正题，我们都知道，AndroidUI是线程不安全的，如果在子线程中尝试进行UI操作，程序就有可能会崩溃。
相信大家在日常的工作当中都会经常遇到这个问题，解决的方案应该也是早已烂熟于心，即创建一个Message对象，然后借助Handler发送出去，之后在Handler的handleMessage（）方法中获得刚才发送的Message对象，然后在这里进行UI操作就不会再出现崩溃了。
这种处理方式被称为异步消息处理线程，虽然我相信大家都会用，可是你知道它背后的原理是什么样的吗？
今天我们就来一起深入探究一下Handler和Message背后的秘密。
首先来看一下如何创建Handler对象。
你可能会觉得挺纳闷的，创建Handler有什么好看的呢，直接new一下不就行了？
确实，不过即使只是简单new一下，还是有不少地方需要注意的，我们尝试在程序中创建两个Handler对象，一个在主线程中创建，一个在子线程中创建，代码如下所示：
[java] viewplaincopy
1.public class MainActivity extends Activity {
2.
3. private Handler handler1;
4.
5. private Handler handler2;
6.
7. @Override
8. protected void onCreate（Bundle savedInstanceState） {
9. super.onCreate（savedInstanceState）;
10. setContentView（R.layout.activity_main）;
11. handler1 = new Handler（）;
12. new Thread（new Runnable（） {
13. @Override
14. public void run（） {
15. handler2 = new Handler（）;
16. }
17. }）.start（）;
18. }
19.
20.}
如果现在运行一下程序，你会发现，在子线程中创建的Handler是会导致程序崩溃的，提示的错误信息为 Can'tcreatehandlerinsidethreadthathasnotcalledLooper.prepare（）。
说是不能在没有调用Looper.prepare（）的线程中创建Handler，那我们尝试在子线程中先调用一下Looper.prepare（）呢，代码如下所示：
[java] viewplaincopy
1.new Thread（new Runnable（） {
2. @Override
3. public void run（） {
4. Looper.prepare（）;
5. handler2 = new Handler（）;
6. }
7.}）.start（）;
果然这样就不会崩溃了，不过只满足于此显然是不够的，我们来看下Handler的源码，搞清楚为什么不调用Looper.prepare（）就不行呢。
Handler的无参构造函数如下所示：
[java] viewplaincopy
1.public Handler（） {
2. if （FIND_POTENTIAL_LEAKS） {
3. final Class
extends Handler> klass = getClass（）;
4. if （（klass.isAnonymousClass（） || klass.isMemberClass（） || klass.isLocalClass（）） &&
5. （klass.getModifiers（） & Modifier.STATIC） == 0） {
6. Log.w（TAG, "The following Handler class should be static or leaks might occur:
" +
7. klass.getCanonicalName（））;
8. }
9. }
10. mLooper = Looper.myLooper（）;
11. if （mLooper == null） {
12. throw new RuntimeException（
13. "Can't create handler inside thread that has not called Looper.prepare（）"）;
14. }
15. mQueue = mLooper.mQueue;
16. mCallback = null;
17.}
可以看到，在第10行调用了Looper.myLooper（）方法获取了一个Looper对象，如果Looper对象为空，则会抛出一个运行时异常，提示的错误正是 Can'tcreatehandlerinsidethreadthathasnotcalledLooper.prepare（）！
那什么时候Looper对象才可能为空呢？
这就要看看Looper.myLooper（）中的代码了，如下所示：
[java] viewplaincopy
1.public static final Looper myLooper（） {
2. return （Looper）sThreadLocal.get（）;
3.}
这个方法非常简单，就是从sThreadLocal对象中取出Looper。
如果sThreadLocal中有Looper存在就返回Looper，如果没有Looper存在自然就返回空了。
因此你可以想象得到是在哪里给sThreadLocal设置Looper了吧，当然是Looper.prepare（）方法！
我们来看下它的源码：
[java] viewplaincopy
1.public static final void prepare（） {
2. if （sThreadLocal.get（） !
= null） {
3. throw new RuntimeException（"Only one Looper may be created per thread"）;
4. }
5. sThreadLocal.set（new Looper（））;
6.}
可以看到，首先判断sThreadLocal中是否已经存在Looper了，如果还没有则创建一个新的Looper设置进去。
这样也就完全解释了为什么我们要先调用Looper.prepare（）方法，才能创建Handler对象。
同时也可以看出每个线程中最多只会有一个Looper对象。
咦？
不对呀！
主线程中的Handler也没有调用Looper.prepare（）方法，为什么就没有崩溃呢？
细心的朋友我相信都已经发现了这一点，这是由于在程序启动的时候，系统已经帮我们自动调用了Looper.prepare（）方法。
查看ActivityThread中的main（）方法，代码如下所示：
[java] viewplaincopy
1.public static void main（String[] args） {
2. SamplingProfilerIntegration.start（）;
3. CloseGuard.setEnabled（false）;
4. Environment.initForCurrentUser（）;
5. EventLogger.setReporter（new EventLoggingReporter（））;
6. Process.setArgV0（""）;
7. Looper.prepareMainLooper（）;
8. ActivityThread thread = new ActivityThread（）;
9. thread.attach（false）;
10. if （sMainThreadHandler == null） {
11. sMainThreadHandler = thread.getHandler（）;
12. }
13. AsyncTask.init（）;
14. if （false） {
15. Looper.myLooper（）.setMessageLogging（new LogPrinter（Log.DEBUG, "ActivityThread"））;
16. }
17. Looper.loop（）;
18. throw new RuntimeException（"Main thread loop unexpectedly exited"）;
19.}
可以看到，在第7行调用了Looper.prepareMainLooper（）方法，而这个方法又会再去调用Looper.prepare（）方法，代码如下所示：
[java] viewplaincopy
1.public static final void prepareMainLooper（） {
2. prepare（）;
3. setMainLooper（myLooper（））;
4. if （Process.supportsProcesses（）） {
5. myLooper（）.mQueue.mQuitAllowed = false;
6. }
7.}
因此我们应用程序的主线程中会始终存在一个Looper对象，从而不需要再手动去调用Looper.prepare（）方法了。
这样基本就将Handler的创建过程完全搞明白了，总结一下就是在主线程中可以直接创建Handler对象，而在子线程中需要先调用Looper.prepare（）才能创建Handler对象。
看完了如何创建Handler之后，接下来我们看一下如何发送消息，这个流程相信大家也已经非常熟悉了，new出一个Message对象，然后可以使用setData（）方法或arg参数等方式为消息携带一些数据，再借助Handler将消息发送出去就可以了，示例代码如下：
[java] viewplaincopy
1.new Thread（new Runnable（） {
2. @Override
3. public void run（） {
4. Message message = new Message（）;
5. message.arg1 = 1;
6. Bundle bundle = new Bundle（）;
7. bundle.putString（"data", "data"）;
8. message.setData（bundle）;
9. handler.sendMessage（message）;
10. }
11.}）.start（）;
可是这里Handler到底是把Message发送到哪里去了呢？
为什么之后又可以在Handler的handleMessage（）方法中重新得到这条Message呢？
看来又需要通过阅读源码才能解除我们心中的疑惑了，Handler中提供了很多个发送消息的方法，其中除了sendMessageAtFrontOfQueue（）方法之外，其它的发送消息方法最终都会辗转调用到sendMessageAtTime（）方法中，这个方法的源码如下所示：
[java] viewplaincopy
1.public boolean sendMessageAtTime（Message msg, long uptimeMillis）
2.{
3. boolean sent = false;
4. MessageQueue queue = mQueue;
5. if （queue !
= null） {
6. msg.target = this;
7. sent = queue.enqueueMessage（msg, uptimeMillis）;
8. }
9. else {
10. RuntimeException e = new RuntimeException（
11. this + " sendMessageAtTime（） called with no mQueue"）;
12. Log.w（"Looper", e.getMessage（）, e）;
13. }
14. return sent;
15.}
sendMessageAtTime（）方法接收两个参数，其中msg参数就是我们发送的Message对象，而uptimeMillis参数则表示发送消息的时间，它的值等于自系统开机到当前时间的毫秒数再加上延迟时间，如果你调用的不是sendMessageDelayed（）方法，延迟时间就为0，然后将这两个参数都传递到MessageQueue的enqueueMessage（）方法中。
这个MessageQueue又是什么东西呢？
其实从名字上就可以看出了，它是一个消息队列，用于将所有收到的消息以队列的形式进行排列，并提供入队和出队的方法。
这个类是在Looper的构造函数中创建的，因此一个Looper也就对应了一个MessageQueue。
那么enqueueMessage（）方法毫无疑问就是入队的方法了，我们来看下这个方法的源码：
[java] viewplaincopy
1.final boolean enqueueMessage（Message msg, long when） {
2. if （msg.when !
= 0） {
3. throw new AndroidRuntimeException（msg + " This message is already in use."）;
4. }
5. if （msg.target == null && !
mQuitAllowed） {
6. throw new RuntimeException（"Main thread not allowed to quit"）;
7. }
8. synchronized （this） {
9. if （mQuiting） {
10. RuntimeException e = new RuntimeException（msg.target + " sending message to a Handler on a dead thread"）;
11. Log.w（"MessageQueue", e.getMessage（）, e）;
12. return false;
13. } else if （msg.target == null） {
14. mQuiting = true;
15. }
16. msg.when = when;
17. Message p = mMessages;
18. if （p == null || when == 0 || when < p.when） {
19. msg.next = p;
20. mMessages = msg;
21. this.notify（）;
22. } else {
23. Message prev = null;
24. while （p !
= null && p.when <= when） {
25. prev = p;
26. p = p.next;
27. }
28. msg.next = prev.next;
29. prev.next = msg;
30. this.notify（）;
31. }
32. }
33. return true;
34.}
首先你要知道，MessageQueue并没有使用一个集合把所有的消息都保存起来，它只使用了一个mMessages对象表示当前待处理的消息。
然后观察上面的代码的16~31行我们就可以看出，所谓的入队其实就是将所有的消息按时间来进行排序，这个时间当然就是我们刚才介绍的uptimeMillis参数。
具体的操作方法就根据时间的顺序调用msg.next，从而为每一个消息指定它的下一个消息是什么。
当然如果你是通过sendMessageAtFrontOfQueue（）方法来发送消息的，它也会调用enqueueMessage（）来让消息入队，只不过时间为0，这时会把mMessages赋值为新入队的这条消息，然后将这条消息的next指定为刚才的mMessages，这样也就完成了添加消息到队列头部的操作。
现在入队操作我们就已经看明白了，那出队操作是在哪里进行的呢?
这个就需要看一看Looper.loop（）方法的源码了，如下所示：
[java] viewplaincopy
1.public static final void loop（） {
2. Looper me = myLooper（）;
3. MessageQueue queue = me.mQueue;
4. while （true） {
5. Message msg = queue.next（）; // might block
6. if （msg !
= null） {
7. if （msg.target == null） {
8. return;
9. }
10. if （me.mLogging!
= null） me.mLogging.println（
11. ">>>>> Dispatching to " + msg.target + " "
12. + msg.callback + ":
" + msg.what
13. ）;
14. msg.target.dispatchMessage（msg）;
15. if （me.mLogging!
= null） me.mLogging.println（
16. "<<<<< Finished to " + msg.target + " "
17. + msg.callback）;
18. msg.recycle（）;
19. }
20. }
21.}
可以看到，这个方法从第4行开始，进入了一个死循环，然后不断地调用的MessageQueue的next（）方法，我想你已经猜到了，这个next（）方法就是消息队列的出队方法。
不过由于这个方法的代码稍微有点长，我就不贴出来了，它的简单逻辑就是如果当前MessageQueue中存在mMessages（即待处理消息），就将这个消息出队，然后让下一条消息成为mMessages，否则就进入一个阻塞状态，一直等到有新的消息入队。
继续看loop（）方法的第14行，每当有一个消息出队，就将它传递到msg.target的dispatchMessage（）方法中，那这里msg.target又是什么呢？
其实就是Handler啦，你观察一下上面sendMessageAtTime（）方法的第6行就可以看出来了。
接下来当然就要看一看Handler中dispatchMessage（）方法的源码了，如下所示：
[java] viewplaincopy
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.}
在第5行进行判断，如果mCallback不为空，则调用mCallback的handleMessage（）方法，否则直接调用Handler的handleMessage（）方法，并将消息对象作为参数传递过去。
这样我相信大家就都明白了为什么handleMessage（）方法中可以获取到之前发送的消息了吧！
因此，一个最标准的异步消息处理线程的写法应该是这样：
[java] viewplainco
升级会员 