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. version="1.0" encoding="utf-8"?>
2.
3. android:orientation="vertical"
4. android:layout_width="fill_parent"
5. android:layout_height="fill_parent"
6. >
7.
8. android:layout_width="fill_parent"
9. android:layout_height="wrap_content"
10. android:text="Hello , Welcome to Andy's Blog!"/>
11.
12. android:id="@+id/download"
13. android:layout_width="fill_parent"
14. android:layout_height="wrap_content"
15. android:text="Download"/>
16.
17. android:id="@+id/tv"
18. android:layout_width="fill_parent"
19. android:layout_height="wrap_content"
20. android:text="当前进度显示"/>
21.
22. android:id="@+id/pb"
23. android:layout_width="fill_parent"
24. android:layout_height="wrap_content"
25. style="?android:attr/progressBarStyleHorizontal"/>
26.
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
>
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="Hello , Welcome to Andy's Blog!"/>
android:id="@+id/download"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="Download"/>
android:id="@+id/tv"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="当前进度显示"/>
android:id="@+id/pb"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
style="?android:attr/progressBarStyleHorizontal"/>
[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
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对象，一个在主线程中创建，一个在子线程中创建，代码如下所示：
- public class MainActivity extends Activity {
- private Handler handler1;
- private Handler handler2;
- @Override
- protected void onCreate(Bundle savedInstanceState) {
- super.onCreate(savedInstanceState);
- setContentView(R.layout.activity_main);
- handler1 = new Handler();
- new Thread(new Runnable() {
- @Override
- public void run() {
- handler2 = new Handler();
- }
- }).start();
- }
- }
- new Thread(new Runnable() {
- @Override
- public void run() {
- Looper.prepare();
- handler2 = new Handler();
- }
- }).start();
- public Handler() {
- if (FIND_POTENTIAL_LEAKS) {
- final Classextends Handler> klass = getClass();
- if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
- (klass.getModifiers() & Modifier.STATIC) == 0) {
- Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
- klass.getCanonicalName());
- }
- }
- mLooper = Looper.myLooper();
- if (mLooper == null) {
- throw new RuntimeException(
- "Can't create handler inside thread that has not called Looper.prepare()");
- }
- mQueue = mLooper.mQueue;
- mCallback = null;
- }
- public static final Looper myLooper() {
- return (Looper)sThreadLocal.get();
- }
- public static final void prepare() {
- if (sThreadLocal.get() != null) {
- throw new RuntimeException("Only one Looper may be created per thread");
- }
- sThreadLocal.set(new Looper());
- }
可以看到，首先判断sThreadLocal中是否已经存在Looper了，如果还没有则创建一个新的Looper设置进去。这样也就完全解释了为什么我们要先调用Looper.prepare()方法，才能创建Handler对象。同时也可以看出每个线程中最多只会有一个Looper对象。
咦？不对呀！主线程中的Handler也没有调用Looper.prepare()方法，为什么就没有崩溃呢？细心的朋友我相信都已经发现了这一点，这是由于在程序启动的时候，系统已经帮我们自动调用了Looper.prepare()方法。查看ActivityThread中的main()方法，代码如下所示：
- public static void main(String[] args) {
- SamplingProfilerIntegration.start();
- CloseGuard.setEnabled(false);
- Environment.initForCurrentUser();
- EventLogger.setReporter(new EventLoggingReporter());
- Process.setArgV0("
" ); - Looper.prepareMainLooper();
- ActivityThread thread = new ActivityThread();
- thread.attach(false);
- if (sMainThreadHandler == null) {
- sMainThreadHandler = thread.getHandler();
- }
- AsyncTask.init();
- if (false) {
- Looper.myLooper().setMessageLogging(new LogPrinter(Log.DEBUG, "ActivityThread"));
- }
- Looper.loop();
- throw new RuntimeException("Main thread loop unexpectedly exited");
- }
- public static final void prepareMainLooper() {
- prepare();
- setMainLooper(myLooper());
- if (Process.supportsProcesses()) {
- myLooper().mQueue.mQuitAllowed = false;
- }
- }
因此我们应用程序的主线程中会始终存在一个Looper对象，从而不需要再手动去调用Looper.prepare()方法了。
这样基本就将Handler的创建过程完全搞明白了，总结一下就是在主线程中可以直接创建Handler对象，而在子线程中需要先调用Looper.prepare()才能创建Handler对象。
看完了如何创建Handler之后，接下来我们看一下如何发送消息，这个流程相信大家也已经非常熟悉了，new出一个Message对象，然后可以使用setData()方法或arg参数等方式为消息携带一些数据，再借助Handler将消息发送出去就可以了，示例代码如下：
- new Thread(new Runnable() {
- @Override
- public void run() {
- Message message = new Message();
- message.arg1 = 1;
- Bundle bundle = new Bundle();
- bundle.putString("data", "data");
- message.setData(bundle);
- handler.sendMessage(message);
- }
- }).start();
可是这里Handler到底是把Message发送到哪里去了呢？为什么之后又可以在Handler的handleMessage()方法中重新得到这条Message呢？看来又需要通过阅读源码才能解除我们心中的疑惑了，Handler中提供了很多个发送消息的方法，其中除了sendMessageAtFrontOfQueue()方法之外，其它的发送消息方法最终都会辗转调用到sendMessageAtTime()方法中，这个方法的源码如下所示：
- public boolean sendMessageAtTime(Message msg, long uptimeMillis)
- {
- boolean sent = false;
- MessageQueue queue = mQueue;
- if (queue != null) {
- msg.target = this;
- sent = queue.enqueueMessage(msg, uptimeMillis);
- }
- else {
- RuntimeException e = new RuntimeException(
- this + " sendMessageAtTime() called with no mQueue");
- Log.w("Looper", e.getMessage(), e);
- }
- return sent;
- }
那么enqueueMessage()方法毫无疑问就是入队的方法了，我们来看下这个方法的源码：
- final boolean enqueueMessage(Message msg, long when) {
- if (msg.when != 0) {
- throw new AndroidRuntimeException(msg + " This message is already in use.");
- }
- if (msg.target == null && !mQuitAllowed) {
- throw new RuntimeException("Main thread not allowed to quit");
- }
- synchronized (this) {
- if (mQuiting) {
- RuntimeException e = new RuntimeException(msg.target + " sending message to a Handler on a dead thread");
- Log.w("MessageQueue", e.getMessage(), e);
- return false;
- } else if (msg.target == null) {
- mQuiting = true;
- }
- msg.when = when;
- Message p = mMessages;
- if (p == null || when == 0 || when < p.when) {
- msg.next = p;
- mMessages = msg;
- this.notify();
- } else {
- Message prev = null;
- while (p != null && p.when <= when) {
- prev = p;
- p = p.next;
- }
- msg.next = prev.next;
- prev.next = msg;
- this.notify();
- }
- }
- return true;
- }
现在入队操作我们就已经看明白了，那出队操作是在哪里进行的呢?这个就需要看一看Looper.loop()方法的源码了，如下所示：
- public static final void loop() {
- Looper me = myLooper();
- MessageQueue queue = me.mQueue;
- while (true) {
- Message msg = queue.next(); // might block
- if (msg != null) {
- if (msg.target == null) {
- return;
- }
- if (me.mLogging!= null) me.mLogging.println(
- ">>>>> Dispatching to " + msg.target + " "
- + msg.callback + ": " + msg.what
- );
- msg.target.dispatchMessage(msg);
- if (me.mLogging!= null) me.mLogging.println(
- "<<<<< Finished to " + msg.target + " "
- + msg.callback);
- msg.recycle();
- }
- }
- }
- public void dispatchMessage(Message msg) {
- if (msg.callback != null) {
- handleCallback(msg);
- } else {
- if (mCallback != null) {
- if (mCallback.handleMessage(msg)) {
- return;
- }
- }
- handleMessage(msg);
- }
- }
因此，一个最标准的异步消息处理线程的写法应该是这样：
- 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();
- }
- }
那么我们还是要来继续分析一下，为什么使用异步消息处理的方式就可以对UI进行操作了呢？这是由于Handler总是依附于创建时所在的线程，比如我们的Handler是在主线程中创建的，而在子线程中又无法直接对UI进行操作，于是我们就通过一系列的发送消息、入队、出队等环节，最后调用到了Handler的handleMessage()方法中，这时的handleMessage()方法已经是在主线程中运行的，因而我们当然可以在这里进行UI操作了。整个异步消息处理流程的示意图如下图所示：
另外除了发送消息之外，我们还有以下几种方法可以在子线程中进行UI操作：
1. Handler的post()方法
2. View的post()方法
3. Activity的runOnUiThread()方法
我们先来看下Handler中的post()方法，代码如下所示：
- public final boolean post(Runnable r)
- {
- return sendMessageDelayed(getPostMessage(r), 0);
- }
- private final Message getPostMessage(Runnable r) {
- Message m = Message.obtain();
- m.callback = r;
- return m;
- }
- private final void handleCallback(Message message) {
- message.callback.run();
- }
- public class MainActivity extends Activity {
- private Handler handler;
- @Override
- protected void onCreate(Bundle savedInstanceState) {
- super.onCreate(savedInstanceState);
- setContentView(R.layout.activity_main);
- handler = new Handler();
- new Thread(new Runnable() {
- @Override
- public void run() {
- handler.post(new Runnable() {
- @Override
- public void run() {
- // 在这里进行UI操作
- }
- });
- }
- }).start();
- }
- }
然后再来看一下View中的post()方法，代码如下所示：
- public boolean post(Runnable action) {
- Handler handler;
- if (mAttachInfo != null) {
- handler = mAttachInfo.mHandler;
- } else {
- ViewRoot.getRunQueue().post(action);
- return true;
- }
- return handler.post(action);
- }
最后再来看一下Activity中的runOnUiThread()方法，代码如下所示：
- public final void runOnUiThread(Runnable action) {
- if (Thread.currentThread() != mUiThread) {
- mHandler.post(action);
- } else {
- action.run();
- }
- }
通过以上所有源码的分析，我们已经发现了，不管是使用哪种方法在子线程中更新UI，其实背后的原理都是相同的，必须都要借助异步消息处理的机制来实现，而我们又已经将这个机制的流程完全搞明白了，真是一件一本万利的事情啊。