Adnroid消息传递机制
我们都知道，Android UI是线程不安全的，如果在子线程中尝试进行UI操作，程序就有可能会崩溃。相信大家在日常的工作当中都会经常遇到这个问题,而解决方法则是通过Android的消息传递去完美解决。这种处理方式被称为异步消息处理线程。
Handler对象的创建：
我们知道，当我们在子线程中通过new去生成 Handler对象的之前，必须调用Looper.prepare() ，如果不这样做，我们的程序会出现一个Can't create handler inside thread that has not called Looper.prepare()的异常。说是我们不能在没有调用Looper.prepare()的线程中new Handler对象，为什么会出现这种情况呢？我们可以分享Handler无参构造函数的源码：
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't create handler inside thread that has not called Looper.prepare()！那么在什么情况Looper.myLooper（）会取得空值呢，那我们就可以看看Looper.myLooper（）源码：
1. public static final Looper myLooper() {
2. return (Looper)sThreadLocal.get();
3. }
这里很清晰的看出，从sThreadLocal对象中取出Looper。如果sThreadLocal中有Looper存在就返回Looper，如果没有Looper存在自然就返回空了。那么问题又来了，looper对象是什么时候放到sThredLocal对象中的呢？通过分析Looper.prepare()方法：
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对象，当sThreadLocal中有Looper对象的时候，我们再调用Looper.prepare（）方法的时候会抛出异常。
其实我们都知道，线程是不需要调用Looper.prepare（）方法的，那这是为什么呢？这是由于在程序启动的时候，系统已经帮我们自动调用了Looper.prepare()方法。查看ActivityThread中的main()方法，通过分析一下源码：
1. ublic static void main(String[] args) {
2. SamplingProfilerIntegration.start();
3. CloseGuard.setEnabled(false);
4. Environment.initForCurrentUser();
5. EventLogger.setReporter(new EventLoggingReporter());
6. Process.setArgV0("<pre-initialized>");
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()方法。源码如下：
1. public static final void prepareMainLooper() {
2. prepare();
3. setMainLooper(myLooper());
4. if (Process.supportsProcesses()) {
5. myLooper().mQueue.mQuitAllowed = false;
6. }
7. }
因此，我们的应用程序的主线程，是不需要主动的去调用Looper.prepare（）方法。
以上基本就将Handler的创建过程完全搞明白了，总结一下就是在主线程中可以直接创建Handler对象，而在子线程中需要先调用Looper.prepare()才能创建Handler对象。
Handler对象是如何发送与接收消息：
这个流程相信大家也已经非常熟悉了，new出一个Message对象，然后可以使用setData()方法或arg参数等方式为消息携带一些数据，再借助Handler将消息发送出去就可以了，示例代码如下：
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()方法中，这个方法的源码如下所示：
public boolean sendMessageAtTime(Message msg, long uptimeMillis)
1. {
2. boolean sent = false;
3. MessageQueue queue = mQueue;
4. if (queue != null) {
5. msg.target = this;
6. sent = queue.enqueueMessage(msg, uptimeMillis);
7. }
8. else {
9. RuntimeException e = new RuntimeException(
10. this + " sendMessageAtTime() called with no mQueue");
11. Log.w("Looper", e.getMessage(), e);
12. }
13. return sent;
14. }
sendMessageAtTime()方法接收两个参数，其中msg参数就是我们发送的Message对象，而uptimeMillis参数则表示发送消息的时间，它的值等于自系统开机到当前时间的毫秒数再加上延迟时间，如果你调用的不是sendMessageDelayed()方法，延迟时间就为0，然后将这两个参数都传递到MessageQueue的enqueueMessage()方法中。这个MessageQueue又是什么东西呢？其实从名字上就可以看出了，它是一个消息队列，用于将所有收到的消息以队列的形式进行排列，并提供入队和出队的方法。这个类是在Looper的构造函数中创建的，因此一个Looper也就对应了一个MessageQueue。
那么enqueueMessage()方法毫无疑问就是入队的方法了，我们来看下这个方法的源码：
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()方法的源码了，如下所示：
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()方法的源码了，如下所示：
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()方法中可以获取到之前发送的消息了吧！
另外除了发送消息之外，我们还有以下几种方法可以在子线程中进行UI操作：
1. Handler的post()方法
2. View的post()方法
3. Activity的runOnUiThread()方法
其实我们可以通过查看Handler的post方法源码：
1. public final boolean post(Runnable r)
2. {
3. return sendMessageDelayed(getPostMessage(r), 0);
4. }
原来这里还是调用了sendMessageDelayed()方法去发送一条消息
并且还使用了getPostMessage()方法将Runnable对象转换成了一条消息，我们来看下这个方法的源码：
1. private final Message getPostMessage(Runnable r) {
2. Message m = Message.obtain();
3. m.callback = r;
4. return m;
5. }
在这个方法中将消息的callback字段的值指定为传入的Runnable对象。在Handler的dispatchMessage()方法中原来有做一个检查，如果Message的callback等于null才会去调用handleMessage()方法，否则就调用handleCallback()方法。那我们快来看下handleCallback()方法中的代码吧：
1. private final void handleCallback(Message message) {
2. message.callback.run();
3. }
这里就是直接调用了一开始传入的Runnable对象的run()方法。因此在子线程中通过Handler的post()方法进行UI操作就可以这么写：public class MainActivity extends Activity {
1.
2. private Handler handler;
3.
4. @Override
5. protected void onCreate(Bundle savedInstanceState) {
6. super.onCreate(savedInstanceState);
7. setContentView(R.layout.activity_main);
8. handler = new Handler();
9. new Thread(new Runnable() {
10. @Override
11. public void run() {
12. handler.post(new Runnable() {
13. @Override
14. public void run() {
15. // 在这里进行UI操作
16. }
17. });
18. }
19. }).start();
20. }
21. }
虽然写法上相差很多，但是原理是完全一样的，我们在Runnable对象的run()方法里更新UI，效果完全等同于在handleMessage()方法中更新UI。
然后再来看一下View中的post()方法，代码如下所示：
1. public boolean post(Runnable action) {
2. Handler handler;
3. if (mAttachInfo != null) {
4. handler = mAttachInfo.mHandler;
5. } else {
6. ViewRoot.getRunQueue().post(action);
7. return true;
8. }
9. return handler.post(action);
10. }
原来就是调用了Handler中的post()方法。
最后再来看一下Activity中的runOnUiThread()方法，代码如下所示：
1. public final void runOnUiThread(Runnable action) {
2. if (Thread.currentThread() != mUiThread) {
3. mHandler.post(action);
4. } else {
5. action.run();
6. }
7. }
如果当前的线程不等于UI线程(主线程)，就去调用Handler的post()方法，否则就直接调用Runnable对象的run()方法。
讲了这么多，我自己总结了一句话：谁有本事搞事情，谁就要负责擦屁股。也就是说，那个线程的handler对象调用sendMessage方法，那么就由该线程的handleMessage方法处理发过来的消息。
1718
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
