Android异步通信机制简单地理解，Handler是当前线程的消息队列中的一个子队列，而Runable是可以被安排到Handler去运行的接口。 首先在Activity中创建一个继承自Han

异步通信一：

简单地理解，Handler是当前线程的消息队列中的一个子队列，而Runable是可以被安排到Handler去运行的接口。

 

首先在Activity中创建一个继承自Handler的匿名内部类以及这个类的一个对象

Private MainHandler mMainHandler = new MainHandler();

private class MainHandler extends Handler {

    public void handleMessage(android.os.Message msg) {

         switch (msg.what) {

         case MSG_MAIN_HANDLER_TEST:

              Log.d(TAG, "handleMessage-->thread id = " +                             

              Thread.currentThread().getId());

              break;

         }

    }

 };

这样在Activity的其他地方就可以通过mMainHandler对象发送消息给Handler处理了

Message msg = mMainHandler.obtainMessage(MSG_MAIN_HANDLER_TEST);

         mMainHandler.sendMessage(msg);

Handler处理runnables方法中的代码

使用Handler发送以及处理消息外，handler还有一个作用就是处理传递给它的action对象，具体使用步骤示例：

1、在主线程中定义Handler对象

2、构造一个runnable对象，为该对象实现runnable方法。

3、在子线程中使用Handler对象post(runnable)对象.

 

handler.post这个函数的作用是把Runnable里面的run方法的这段代码发送到消息队列中，等待运行。
如果handler是以UI线程消息队列为参数构造的，那么是把run里面的代码发送到UI线程中，等待UI线程运行这段代码。如果handler是以子线程线程消息队列为参数构造的，那么是把run里面的代码发送到子线程中，等待子线程运行这段代码。

 

Runnable本身并不是一个线程，只是接口，但是这个接口可以在别的线程中运行

 

public class TestActivity extends Activity implements OnClickListener {

     private Button mBtnTest=null;

     private Handler myHandler=null;

    @Override

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.main);

       

        mBtnTest=(Button)findViewById(R.id.btn_test);

        mBtnTest.setOnClickListener(this);       

        myHandler=new Handler();

    }

     @Override

     public void onClick(View v) {

         //注意:此处UI线程被阻塞，因为myHandler是在UI线程中创建的

         myHandler.post(new Runnable() {

              public void run() {

                   long i=0;

                  while(true){

                  i++;

                  }

                   }

              });

     }

}

这里我们看代码 mHandler.post(new Runnable(){  好像是new 了一个 interface，其实是new的一个实现Runnable的匿名内部类（Inner Anonymous Class），这是很简练的写法。

上面的代码可以看成是： new anonymousClass() implement interface{ [改写interface method]}

Runnable是一个接口，不是一个线程，一般线程会实现Runnable。所以如果我们使用匿名内部类是运行在UI主线程的，如果我们使用实现这个Runnable接口的线程类，则是运行在对应线程的。

而Android应用程序是消息驱动的。Android通过Looper、Handler来实现消息循环机制，Android消息循环是针对线程的（每个线程都可以有自己的消息队列和消息循环）。

Message：消息，其中包含了消息ID，消息处理对象以及处理的数据等，由MessageQueue统一列队，终由Handler处理。

Handler：处理者，负责Message的发送及处理。使用Handler时，需要实现handleMessage(Message msg)方法来对特定的Message进行处理。

MessageQueue：消息队列，用来存放Handler发送过来的消息，并按照FIFO规则执行。当然，存放Message并非实际意义的保存，而是将Message以链表的方式串联起来的，等待Looper的抽取。

Looper：消息泵，不断地从MessageQueue中抽取Message执行。因此，一个MessageQueue需要一个Looper。

Thread：线程，负责调度整个消息循环，即消息循环的执行场所。

Handler，Looper和MessageQueue就是简单的三角关系。Looper和MessageQueue一一对应，创建一个 Looper的同时，会创建一个MessageQueue。而Handler与它们的关系，只是简单的聚集关系，即Handler里会引用当前线程里的特定Looper和MessageQueue。

这样说来，多个Handler都可以共享同一Looper和MessageQueue了。当然，这些Handler也就运行在同一个线程里。

如何实现消息的发送与处理

接下来，我们简单地看一下消息的循环过程：

A消息的生成

       Message msg = mHandler.obtainMessage();

       msg.what = what;

       msg.sendToTarget();

B消息的发送

       MessageQueue queue = mQueue;

        if (queue != null) {

            msg.target = this;

            sent = queue.enqueueMessage(msg, uptimeMillis);

        }

在Handler.java 的sendMessageAtTime(Message msg, long uptimeMillis)方法中，我们看到，它找到它所引用的MessageQueue，然后将Message的target设定成自己（目的是为了在处理消息环节，Message能找到正确的Handler），再将这个Message纳入到消息队列中。

C消息的抽取

        Looper me = myLooper();

        MessageQueue queue = me.mQueue;

        while (true) {

            Message msg = queue.next(); // might block

            if (msg != null) {

                if (msg.target == null) {

                    // No target is a magic identifier for the quit message.

                    return;

                }

                msg.target.dispatchMessage(msg);

                msg.recycle();

            }

        }

在Looper.java 的loop()函数里，我们看到，这里有一个死循环，不断地从MessageQueue中获取下一个（next方法）Message，然后通过Message中携带的target信息，交由正确的Handler处理（dispatchMessage方法）。

D消息的处理

        if (msg.callback != null) {

            handleCallback(msg);

        } else {

            if (mCallback != null) {

                if (mCallback.handleMessage(msg)) {

                    return;

                }

            }

            handleMessage(msg);

        }

在Handler.java的dispatchMessage(Message msg)方法里，其中的一个分支就是调用handleMessage方法来处理这条Message，而这也正是我们在职责处描述使用Handler时需要实现handleMessage(Message msg)的原因。

一个Message经由Handler的发送，MessageQueue的入队，Looper的抽取，又再一次地回到Handler的怀抱。而绕的这一圈，也正好帮助我们将同步操作变成了异步操作。

异步通信二：

在工作线程中使用Handler

在UI线程中已经有了Looper,但是在工作线程中要自己实现Looper：

       class LooperThread extends Thread {

                public Handler mHandler;

                   public void run() {

                       Looper.prepare();

                       mHandler = new Handler() {

                            public void handleMessage(Message msg) {

                            // process incoming messages here

                             }

                        };

                        Looper.loop(); //不能在这个后面添加代码，程序是无法运行到这行之后的

                   }

      }

在创建Handler之前，为该线程准备好一个Looper（Looper.prepare），然后让这个Looper跑起来（Looper.loop），抽取Message，这样，Handler才能正常工作。

不是所有的Handler都能更新UI

    Handler处理消息总是在创建Handler的线程里运行。而我们的消息处理中，不乏更新UI的操作，不正确的线程直接更新UI将引发异常。因此，需要时刻关心Handler在哪个线程里创建的。如何更新UI才能不出异常呢？SDK告诉我们，有以下4种方式可以从其它线程访问UI线程(也即线程间通信)：

·      Activity.runOnUiThread(Runnable)

·      View.post(Runnable)

·      View.postDelayed(Runnable, long)

·      在UI线程中创建的Handler

其中，重点说一下的是View.post(Runnable)方法。在post(Runnable action)方法里，View获得当前线程（即UI线程）的Handler，然后将action对象post到Handler里。在Handler里，它将传递过来的action对象包装成一个Message（Message的callback为action），然后将其投入UI线程的消息循环中。在 Handler再次处理该Message时，有一条分支（未解释的那条）就是为它所设，直接调用runnable的run方法。而此时，已经路由到UI线程里，因此，我们可以毫无顾虑的来更新UI。

几点小结

·      Handler的处理过程运行在创建Handler的线程里

·      一个Looper对应一个MessageQueue，一个线程对应一个Looper，一个Looper可以对应多个Handler

·      不确定当前线程时，更新UI时尽量调用View.post方法

·      handler应该由处理消息的线程创建。

·      handler与创建它的线程相关联，而且也只与创建它的线程相关联。handler运行在创建它的线程中，所以，如果在handler中进行耗时的操作，会阻塞创建它的线程。

·      Android的线程分为有消息循环的线程和没有消息循环的线程，有消息循环的线程一般都会有一个Looper。主线程（UI线程）就是一个消息循环的线程。

·      Looper.myLooper();      //获得当前的Looper

        Looper.getMainLooper () //获得UI线程的Lopper

·      Handle的初始化函数（构造函数），如果没有参数，那么他就默认使用的是当前的Looper，如果有Looper参数，就是用对应的线程的Looper。

·      如果一个线程中调用Looper.prepare()，那么系统就会自动的为该线程建立一个消息队列，然后调用 Looper.loop();之后就进入了消息循环，这个之后就可以发消息、取消息、和处理消息。

Android提供了一个封装好的带有looper的线程类，即为HandlerThread，具体可参见下面的代码：

public class HandlerThreadActivity extends Activity {

     private static final String TAG = "HandlerThreadActivity";

     private HandlerThread mHandlerThread;

     private MyHandler mMyHandler;

     @Override

     protected void onCreate(Bundle savedInstanceState) {

         // TODO Auto-generated method stub

         super.onCreate(savedInstanceState);

         TextView text = new TextView(this);

         text.setText("HandlerThreadActivity");

         setContentView(text);

         Log.d(TAG, "The main thread id = " +      Thread.currentThread().getId());

         //生成一个HandlerThread对象，实现了使用Looper来处理消息队列的功能，

         //这个类由Android应用程序框架提供

         mHandlerThread = new HandlerThread("handler_thread");

        

         //在使用HandlerThread的getLooper()方法之前，必须先调用该类的start();

         mHandlerThread.start();

         //即这个Handler是运行在mHandlerThread这个线程中

         mMyHandler = new MyHandler(mHandlerThread.getLooper());

        

         mMyHandler.sendEmptyMessage(1);

     }

      private class MyHandler extends Handler {

   

         public MyHandler(Looper looper) {

              super(looper);

         }

 

         @Override

         public void handleMessage(Message msg) {

              Log.d(TAG, "MyHandler-->handleMessage-->thread id = " + Thread.currentThread().getId());

              super.handleMessage(msg);

         }

     }

    

}

异步通信三：

AsyncTask

阅读浏览器的代码，可以看到 BrowserActivity.java在Oncreate()里创建了AsyncTask, 为什么不使用前面提到的Handler呢？

AsyncTask的特点是任务在主线程之外运行，而回调方法是在主线程中执行，这就有效地避免了使用Handler带来的麻烦。阅读AsyncTask的源码可知，AsyncTask是使用java.util.concurrent框架来管理线程以及任务的执行的。如果联网请求的的时候使用匿名线程:第一，匿名线程的开销较大，如果每个任务都要创建一个线程，那么应用程序的效率要低很多；第二，匿名线程无法管理，匿名线程创建并启动后就不受程序的控制了，如果有很多个请求发送，那么就会启动非常多的线程，系统将不堪重负。

AsyncTask是抽象类，子类必须实现抽象方法doInBackground(Params... p) ，在此方法中实现任务的执行工作，比如连接网络获取数据等。通常还应该实现onPostExecute(Result r)方法，因为应用程序关心的结果在此方法中返回。需要注意的是AsyncTask一定要在主线程中创建实例。AsyncTask定义了三种泛型类型Params，Progress和Result。

•Params 启动任务执行的输入参数，比如HTTP请求的URL。
•Progress 后台任务执行的百分比。 
•Result 后台执行任务最终返回的结果，比如String。 

AsyncTask的执行分为四个步骤，与TaskListener类似。每一步都对应一个回调方法，需要注意的是这些方法不应该由应用程序调用，需要做的就是实现这些方法。在任务的执行过程中，这些方法被自动调用。
 1) 继承AsyncTask
 2) 实现AsyncTask中定义的下面一个或几个方法
•onPreExecute() 当任务执行之前开始调用此方法，可以在这里显示进度对话框。这个方法可以不用实现
•doInBackground(Params...) 此方法在后台线程执行，完成任务的主要工作，通常需要较长的时间。在执行过程中可以调用publishProgress (Progress...)来更新任务的进度。
•onProgressUpdate(Progress...) 此方法在主线程执行，用于显示任务执行的进度。
•onPostExecute(Result) 此方法在主线程执行，任务执行的结果作为此方法的参数返回。后台的计算结果将通过该方法传递到UI 线程，并且在界面上展示给用户

•onCancelled(),在用户取消线程操作的时候调用。在主线程中调用onCancelled()的时候调用为了正确的使用AsyncTask类，以下是几条必须遵守的准则：

    　　1) Task的实例必须在UI 线程中创建

    　　2) execute方法必须在UI 线程中调用

    　　3) 不要手动的调用onPreExecute(), onPostExecute(Result)，doInBackground(Params...), onProgressUpdate(Progress...)这几个方法，需要在UI线程中实例化这个task来调用。

    　　4) 该task只能被执行一次，否则多次调用时将会出现异常

      doInBackground方法和onPostExecute的参数必须对应，这两个参数在AsyncTask声明的泛型参数列表中指定，第一个为doInBackground接受的参数，第二个为显示进度的参数，第三个为doInBackground返回和onPostExecute传入的参数。

下面通过一个Demo来说明如何使用Android.os.AsyncTask类，通过进度条来显示进行的进度，然后用TextView显示进度值。程序结构图如下：

[1] \layout\main.xml 布局文件源码如下：

[html] view plaincopyprint?

1.   <?xml version="1.0" encoding="utf-8"?>  

2.   <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  

3.       android:orientation="vertical"  

4.       android:layout_width="fill_parent"  

5.       android:layout_height="fill_parent"  

6.       >  

7.       <TextView    

8.          android:layout_width="fill_parent"   

9.          android:layout_height="wrap_content"   

10.         android:text="Hello , Welcome to Andy's Blog!"/>  

11.      <Button  

12.         android:id="@+id/download"  

13.         android:layout_width="fill_parent"  

14.         android:layout_height="wrap_content"  

15.         android:text="Download"/>  

16.      <TextView    

17.         android:id="@+id/tv"  

18.         android:layout_width="fill_parent"   

19.         android:layout_height="wrap_content"   

20.         android:text="当前进度显示"/>  

21.      <ProgressBar  

22.         android:id="@+id/pb"  

23.         android:layout_width="fill_parent"  

24.         android:layout_height="wrap_content"  

25.         style="?android:attr/progressBarStyleHorizontal"/>  

26.  </LinearLayout>  

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

    android:orientation="vertical"

    android:layout_width="fill_parent"

    android:layout_height="fill_parent"

    >

    <TextView  

       android:layout_width="fill_parent" 

       android:layout_height="wrap_content" 

       android:text="Hello , Welcome to Andy's Blog!"/>

    <Button

       android:id="@+id/download"

       android:layout_width="fill_parent"

       android:layout_height="wrap_content"

       android:text="Download"/>

    <TextView  

       android:id="@+id/tv"

       android:layout_width="fill_parent" 

       android:layout_height="wrap_content" 

       android:text="当前进度显示"/>

    <ProgressBar

       android:id="@+id/pb"

       android:layout_width="fill_parent"

       android:layout_height="wrap_content"

       style="?android:attr/progressBarStyleHorizontal"/>

</LinearLayout>

 

 [2] /src中的MainActivity.java源码如下：

[html] view plaincopyprint?

1.   package com.andyidea.demo;  

2.     

3.   import android.app.Activity;  

4.   import android.os.AsyncTask;  

5.   import android.os.Bundle;  

6.   import android.view.View;  

7.   import android.widget.Button;  

8.   import android.widget.ProgressBar;  

9.   import android.widget.TextView;  

10.    

11.  public class MainActivity extends Activity {  

12.            

13.      Button download;  

14.      ProgressBar pb;  

15.      TextView tv;  

16.        

17.      /** Called when the activity is first created. */  

18.      @Override  

19.      public void onCreate(Bundle savedInstanceState) {  

20.          super.onCreate(savedInstanceState);  

21.          setContentView(R.layout.main);  

22.          pb=(ProgressBar)findViewById(R.id.pb);  

23.          tv=(TextView)findViewById(R.id.tv);  

24.            

25.          download = (Button)findViewById(R.id.download);  

26.          download.setOnClickListener(new View.OnClickListener() {  

27.              @Override  

28.              public void onClick(View v) {  

29.                  DownloadTask dTask = new DownloadTask();  

30.                  dTask.execute(100);  

31.              }  

32.          });  

33.      }  

34.        

35.      class DownloadTask extends AsyncTask<Integer, Integer, String>{  

36.          //后面尖括号内分别是参数（例子里是线程休息时间），进度(publishProgress用到)，返回值 类型  

37.            

38.          @Override  

39.          protected void onPreExecute() {  

40.              //第一个执行方法  

41.              super.onPreExecute();  

42.          }  

43.            

44.          @Override  

45.          protected String doInBackground(Integer... params) {  

46.              //第二个执行方法,onPreExecute()执行完后执行  

47.              for(int i=0;i<=100;i++){  

48.                  pb.setProgress(i);  

49.                  publishProgress(i);  

50.                  try {  

51.                      Thread.sleep(params[0]);  

52.                  } catch (InterruptedException e) {  

53.                      e.printStackTrace();  

54.                  }  

55.              }  

56.              return "执行完毕";  

57.          }  

58.    

59.          @Override  

60.          protected void onProgressUpdate(Integer... progress) {  

61.              //这个函数在doInBackground调用publishProgress时触发，虽然调用时只有一个参数  

62.              //但是这里取到的是一个数组,所以要用progesss[0]来取值  

63.              //第n个参数就用progress[n]来取值  

64.              tv.setText(progress[0]+"%");  

65.              super.onProgressUpdate(progress);  

66.          }  

67.    

68.          @Override  

69.          protected void onPostExecute(String result) {  

70.              //doInBackground返回时触发，换句话说，就是doInBackground执行完后触发  

71.              //这里的result就是上面doInBackground执行后的返回值，所以这里是"执行完毕"  

72.              setTitle(result);  

73.              super.onPostExecute(result);  

74.          }  

75.            

76.      }  

77.  }  

异步通信四：

我们都知道，Android UI是线程不安全的，如果在子线程中尝试进行UI操作，程序就有可能会崩溃。相信大家在日常的工作当中都会经常遇到这个问题，解决的方案应该也是早已烂熟于心，即创建一个Message对象，然后借助Handler发送出去，之后在Handler的handleMessage()方法中获得刚才发送的Message对象，然后在这里进行UI操作就不会再出现崩溃了。

这种处理方式被称为异步消息处理线程，虽然我相信大家都会用，可是你知道它背后的原理是什么样的吗？今天我们就来一起深入探究一下Handler和Message背后的秘密。

首先来看一下如何创建Handler对象。你可能会觉得挺纳闷的，创建Handler有什么好看的呢，直接new一下不就行了？确实，不过即使只是简单new一下，还是有不少地方需要注意的，我们尝试在程序中创建两个Handler对象，一个在主线程中创建，一个在子线程中创建，代码如下所示：

[java] view plaincopy

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't create handler inside thread that has not called Looper.prepare() 。说是不能在没有调用Looper.prepare() 的线程中创建Handler，那我们尝试在子线程中先调用一下Looper.prepare()呢，代码如下所示：

[java] view plaincopy

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] view plaincopy

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对象才可能为空呢？这就要看看Looper.myLooper()中的代码了，如下所示：

[java] view plaincopy

1. public static final Looper myLooper() {  
2.     return (Looper)sThreadLocal.get();  
3. }  

这个方法非常简单，就是从sThreadLocal对象中取出Looper。如果sThreadLocal中有Looper存在就返回Looper，如果没有Looper存在自然就返回空了。因此你可以想象得到是在哪里给sThreadLocal设置Looper了吧，当然是Looper.prepare()方法！我们来看下它的源码：

[java] view plaincopy

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] view plaincopy

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("<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()方法，代码如下所示：

[java] view plaincopy

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] view plaincopy

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] view plaincopy

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] view plaincopy

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] view plaincopy

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] view plaincopy

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] view plaincopy

1. class LooperThread extends Thread {  
2.       public Handler mHandler;  
3.   
4.       public void run() {  
5.           Looper.prepare();  
6.   
7.           mHandler = new Handler() {  
8.               public void handleMessage(Message msg) {  
9.                   // process incoming messages here  
10.               }  
11.           };  
12.   
13.           Looper.loop();  
14.       }  
15.   }  

当然，这段代码是从Android官方文档上复制的，不过大家现在再来看这段代码，是不是理解的更加深刻了？

那么我们还是要来继续分析一下，为什么使用异步消息处理的方式就可以对UI进行操作了呢？这是由于Handler总是依附于创建时所在的线程，比如我们的Handler是在主线程中创建的，而在子线程中又无法直接对UI进行操作，于是我们就通过一系列的发送消息、入队、出队等环节，最后调用到了Handler的handleMessage()方法中，这时的handleMessage()方法已经是在主线程中运行的，因而我们当然可以在这里进行UI操作了。整个异步消息处理流程的示意图如下图所示：

另外除了发送消息之外，我们还有以下几种方法可以在子线程中进行UI操作：

1. Handler的post()方法

2. View的post()方法

3. Activity的runOnUiThread()方法

我们先来看下Handler中的post()方法，代码如下所示：

[java] view plaincopy

1. public final boolean post(Runnable r)  
2. {  
3.    return  sendMessageDelayed(getPostMessage(r), 0);  
4. }  

原来这里还是调用了sendMessageDelayed()方法去发送一条消息啊，并且还使用了getPostMessage()方法将Runnable对象转换成了一条消息，我们来看下这个方法的源码：

[java] view plaincopy

1. private final Message getPostMessage(Runnable r) {  
2.     Message m = Message.obtain();  
3.     m.callback = r;  
4.     return m;  
5. }  

在这个方法中将消息的callback字段的值指定为传入的Runnable对象。咦？这个callback字段看起来有些眼熟啊，喔！在Handler的dispatchMessage()方法中原来有做一个检查，如果Message的callback等于null才会去调用handleMessage()方法，否则就调用handleCallback()方法。那我们快来看下handleCallback()方法中的代码吧：

[java] view plaincopy

1. private final void handleCallback(Message message) {  
2.     message.callback.run();  
3. }  

也太简单了！竟然就是直接调用了一开始传入的Runnable对象的run()方法。因此在子线程中通过Handler的post()方法进行UI操作就可以这么写：

[java] view plaincopy

1. public class MainActivity extends Activity {  
2.   
3.     private Handler handler;  
4.   
5.     @Override  
6.     protected void onCreate(Bundle savedInstanceState) {  
7.         super.onCreate(savedInstanceState);  
8.         setContentView(R.layout.activity_main);  
9.         handler = new Handler();  
10.         new Thread(new Runnable() {  
11.             @Override  
12.             public void run() {  
13.                 handler.post(new Runnable() {  
14.                     @Override  
15.                     public void run() {  
16.                         // 在这里进行UI操作  
17.                     }  
18.                 });  
19.             }  
20.         }).start();  
21.     }  
22. }  

虽然写法上相差很多，但是原理是完全一样的，我们在Runnable对象的run()方法里更新UI，效果完全等同于在handleMessage()方法中更新UI。

然后再来看一下View中的post()方法，代码如下所示：

[java] view plaincopy

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()方法，代码如下所示：

[java] view plaincopy

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()方法。还有什么会比这更清晰明了的吗？

通过以上所有源码的分析，我们已经发现了，不管是使用哪种方法在子线程中更新UI，其实背后的原理都是相同的，必须都要借助异步消息处理的机制来实现，而我们又已经将这个机制的流程完全搞明白了，真是一件一本万利的事情啊。