联合学习 Android 异步消息处理机制 让你深入理解 Looper、Handler、Message三者关系
1. 首先我们通过一个实例案例来引出一个异常：
（1）布局文件activity_main.xml：
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity" > <TextView
android:id="@+id/tv"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerHorizontal="true"
android:layout_centerVertical="true"
android:text="@string/hello_world" /> </RelativeLayout>
（2）MainActivity.java：
package com.itheima.testthread; import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.widget.EditText;
import android.widget.TextView; public class MainActivity extends Activity { @Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
System.out.println(Thread.currentThread().getName());
final TextView tv = (TextView) findViewById(R.id.tv);
new Thread() {
public void run() {
for (int i = 0; i < 100; i++) {
tv.setText("哈哈哈"+i);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
}.start();
} }
（3）布署程序到模拟器上，出现如下效果，程序直接stop;并且直接报出异常错误：
报错：
android.view.ViewRootImpl$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.
意思：从错误线程调用的异常。谁创建的view，谁才能修改编辑view，只有主线程才可以修改view（所有的View都是主线程创建的）。
上面的报错是ViewRootImpl对UI操作做了验证，这个验证工作是由ViewRootImpl的checkThread方法来完成的，如下所示：
void checkThread() {
if(mThread != Thread.currentThread()) {
throw new CalledFromWrongThreadException(" Only the
original thread that created a view hierarchy can touch its views.");
}
}
总结：上面报这个CalledFromWrongThreadException错误，是因为只有主线程才能修改View更新UI，但是我们这里却自己新建一个线程new Thread（）其中run（）的内容涉及到更新UI，这是不允许的，所有才会出现这样的错误警告。
但是往往我们编写程序的时候设计多个线程需要控制UI显示，但是我们上面已经说过了UI更新只能交给主线程，为了解决这个矛盾，解放程序员，google开发出来消息机制，用来子线程和主线程通信，子线程要更新UI，就会发送消息数据给主线程，这样主线程就会更新相应的UI界面，从而解决这个矛盾。
（4）系统为什么不允许在子线程中访问UI呢 ?
这是因为Android的UI控件不是线程安全的，如果在多线程中并发访问可能会导致UI控件处于不可预期的状态，那为什么系统不对UI控件的访问加锁呢? 缺点有两个：
首先加上锁机制会让UI访问的逻辑变得复杂；其次锁机制会降低UI访问的效率，这是因为锁机制会阻塞某些线程的执行。
鉴于这两个缺点，最简单且高效的方法就是采用单线程模型去处理UI操作，对于开发者来说也不是很麻烦，只需要通过Handler切换一下UI访问的执行线程即可。
2. 消息机制的原理和实现
消息机制实现逻辑图：
这里handler负责把外面的子线程的消息发到message queue消息队列之中，然后looper会以无限循环的形式查看message queue里面是不是有新消息，如果有的话，looper就把消息发送到handler，交给handler的handlemessage根据信息，更新UI，否则就一直等待。
Looper中还有一个特殊的概念，那就是ThreadLocal，ThreadLocal不是线程，它的作用是可以在每个线程中存储数据。我们知道，Handler创建的时候会采用当前的线程的Looper来构造消息循环系统，那么Handler内部如何获取当前线程的Looper呢 ? 这就是要使用ThreadLocal了，ThreadLocal可以在不同线程中互不干扰地存储并提供数据，通过ThreadLocal可以轻松获取每个线程的Looper。当然需要注意的是，线程默认是没有Looper，如果需要使用Handler就必须为线程创建Looper。我们经常提到的主线程，也叫UI线程，它就是ActivityThread，ActivityThread被创建时候就会初始化Looper，这也就是主线程中默认可以使用Handler的原因。
使用消息机制目的：
Android系统的主线程安全的系统，别的线程不可以修改ui线程的界面，如果子线程里面想要更新UI，就必须采用消息机制处理。
使用handler消息处理器编写代码步骤：
（1）在主线程里面声明消息处理器handler；
private Handler handler = new Handler() { };
（2）子线程想要更新UI，利用消息机制
Message msg = new Message();
msg.what 消息类型
msg.obj 具体消息携带的数据
handler.sendMessage(msg);
（3）系统内部有消息队列message queue和消息looper，轮询到消息，交给handler去处理：
（4）重写handler的方法处理消息：
public void handleMessage (Message msg) {
//运行在主线程，更新UI
};
接下来我们就修改上面的案例，就更好理解这个消息机制：
MainActivity.java:
package com.itheima.testthread; import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.widget.EditText;
import android.widget.TextView; public class MainActivity extends Activity {
private TextView tv;
private Handler handler = new Handler() {
public void handleMessage(Message msg) {
// 运行在主线程，更新ui
String str = (String) msg.obj;
tv.setText(str);
EditText et; };
}; @Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
System.out.println(Thread.currentThread().getName());
tv = (TextView) findViewById(R.id.tv);
new Thread() {
public void run() {
for (int i = 0; i < 100; i++) {
// tv.setText("哈哈哈"+i);
Message msg = new Message();
msg.obj = "哈哈哈" + i;
handler.sendMessage(msg);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
}.start();
} }
acitivity_main.xml:
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity" > <TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerHorizontal="true"
android:layout_centerVertical="true"
android:text="@string/hello_world" /> </RelativeLayout>
3. Hanlder之 --- 传递Message --- 传递Runnable对象
（1）简介：
一般来说在工作线程中执行耗时任务，当任务完成时，会返回UI线程，一般是更新UI。这时有两种方法可以达到目的。
一种是：handler.sendMessage。发一个消息，，它是一个Message，再根据消息，执行相关任务代码。
另一种是：handler.post(r)。r是要执行的任务代码，r是Runnable对象。意思就是说r的代码实际是在UI线程执行的。可以写更新UI的代码。（工作线程是不能更新UI的）
（2） 传递Message。用于接受子线程发送的数据, 并用此数据配合主线程更新UI。
在Android中，对于UI的操作通常需要放在主线程中进行操作。如果在子线程中有关于UI的操作，那么就需要把数据消息作为一个Message对象发送到Handler的消息队列中，然后，有Handler中的handlerMessge方法处理传过来的数据信息，并操作UI。当然，Handler对象是在主线程中初始化的，以为它需要绑定在主线程的消息队列中。
类sendMessage(Message msg)方法实现发送消息的操作。在初始化Handler对象时重写的handleMessage方法来接收Messgae并进行相关操作：
//Handler处理子线程消息代码示例：
public class Activity01 extends Activity
{
//声明ProgressBar对象
private ProgressBar m_ProgressBar;
private ProgressBar m_ProgressBar2;
private Button mButton01;
protected static final int GUI_STOP_NOTIFIER = 0x108;
protected static final int GUI_THREADING_NOTIFIER = 0x109; public int intCounter=0; @Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
//设置窗口模式，，因为需要显示进度条在标题栏
requestWindowFeature(Window.FEATURE_PROGRESS);
setProgressBarVisibility(true);
setContentView(R.layout.main);
//取得ProgressBar
m_ProgressBar = (ProgressBar) findViewById(R.id.ProgressBar01);
m_ProgressBar2= (ProgressBar) findViewById(R.id.ProgressBar02);
mButton01 = (Button)findViewById(R.id.Button01);
m_ProgressBar.setIndeterminate(false);
m_ProgressBar2.setIndeterminate(false);
//当按钮按下时开始执行,
mButton01.setOnClickListener(new Button.OnClickListener()
{
@Override
public void onClick(View v)
{
// TODO Auto-generated method stub
//设置ProgressBar为可见状态
m_ProgressBar.setVisibility(View.VISIBLE);
m_ProgressBar2.setVisibility(View.VISIBLE);
//设置ProgressBar的最大值
m_ProgressBar.setMax(100);
//设置ProgressBar当前值
m_ProgressBar.setProgress(0);
m_ProgressBar2.setProgress(0);
//通过线程来改变ProgressBar的值
new Thread(new Runnable() {
public void run()
{
for (int i = 0; i < 10; i++)
{
try
{
intCounter = (i + 1) * 20;
Thread.sleep(1000);
if (i == 4)
{
Message m = new Message();
m.what = Activity01.GUI_STOP_NOTIFIER;
Activity01.this.myMessageHandler.sendMessage(m);
//将message发送到消息队列
break;
}
else
{
Message m = new Message();
m.what = Activity01.GUI_THREADING_NOTIFIER;
Activity01.this.myMessageHandler.sendMessage(m);
//将message发送到消息队列
}
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
}).start();
}
});
} //通过匿名类复写Handler类中的handleMessage方法，用于接收传递到消息队列中的Message，并进行UI操作。
Handler myMessageHandler = new Handler()
{
// @Override
public void handleMessage(Message msg)
{
switch (msg.what)
{
//ProgressBar已经是对大值
case Activity01.GUI_STOP_NOTIFIER:
m_ProgressBar.setVisibility(View.GONE);
m_ProgressBar2.setVisibility(View.GONE);
Thread.currentThread().interrupt();
break;
case Activity01.GUI_THREADING_NOTIFIER:
if (!Thread.currentThread().isInterrupted())
{
// 改变ProgressBar的当前值
m_ProgressBar.setProgress(intCounter);
m_ProgressBar2.setProgress(intCounter);
// 设置标题栏中前景的一个进度条进度值
setProgress(intCounter*100);
// 设置标题栏中后面的一个进度条进度值
setSecondaryProgress(intCounter*100);//
}
break;
}
super.handleMessage(msg);
}
};
}
以上的例子中，子线程只是对进度条的参数进行了变更，并将结果以message形式发送到消息队列中去，子线程的内部并未进行UI操作，而是在重写的Handler的handlerMessage方法中操作了UI界面。
（3）传递Runnable对象。用于通过Handler绑定的消息队列，安排不同操作的执行顺序。
Handler对象在进行初始化的时候，会默认的自动绑定消息队列。利用类post方法，可以将Runnable对象发送到主线程的消息队列中，按照队列的机制按顺序执行不同的Runnable对象中的run方法。
public class HandlerActivity extends Activity {
//声明两个按钮控件
private Button startButton = null;
private Button endButton = null;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
//根据控件的ID得到代表控件的对象，并未这两个按钮设置相应的监听器
startButton = (Button)findViewById(R.id.startButton);
startButton.setOnClickListener(new StartButtonListener());
endButton = (Button)findViewById(R.id.endButton);
endButton.setOnClickListener(new EndButtonListener());
}
class StartButtonListener implements OnClickListener{
@Override
public void onClick(View v) {
//调用Handler的post方法，将要执行的线程对象添加到队列当中
handler.post(updateThread);
}
}
class EndButtonListener implements OnClickListener{
@Override
public void onClick(View v) {
handler.removeCallbacks(updateThread);
}
}
//创建一个Handler对象
Handler handler = new Handler();
//将要执行的操作写在线程对象的run方法当中
Runnable updateThread = new Runnable(){
@Override
public void run() {
System.out.println("UpdateThread");
//在run方法内部，执行postDelayed或者是post方法
handler.postDelayed(updateThread, 3000);
}
};
}
程序的运行结果就是每隔3秒钟，就会在控制台打印一行UpdateTread。这是因为实现了Runnable接口的updateThread对象进入了空的消息队列即被立即执行run方法，而在run方法的内部，又在3000ms之后将其再次发送进入消息队列中。
注意：
post方法虽然发送的是一个实现了Runnable接口的类对象，但是它并非创建了一个新线程，而是执行了该对象中的run方法。也就是说，整个run中的操作和主线程处于同一个线程。
（4）多线程中传递Runnable对象
这样对于那些简单的操作，似乎并不会影响。但是对于耗时较长的操作，当它被加入到消息队列中之后执行会占用很长的时间，以至于处于同一线程的其他操作无法继续执行，就会出现“假死”。为了解决这个问题，就需要使得handler绑定到一个新开启线程的消息队列上，在这个处于另外线程的上的消息队列中处理传过来的Runnable对象和消息。
具体操作方法如下：
public class HandlerTest2 extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
// TODO Auto-generated method stub
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
//打印了当前线程的ID
System.out.println("Activity-->" + Thread.currentThread().getId());
//生成一个HandlerThread对象
HandlerThread handlerThread = new HandlerThread("handler_thread");
//在使用HandlerThread的getLooper()方法之前，必须先调用该类的start()，同时开启一个新线程;
handlerThread.start();
//将由HandlerThread获取的Looper传递给Handler对象，即由处于另外线程的Looper代替handler初始化时默认绑定的消息队列来处理消息。——关键是这句
MyHandler myHandler = new MyHandler(handlerThread.getLooper());
Message msg = myHandler.obtainMessage();
//将msg发送到目标对象，所谓的目标对象，就是生成该msg对象的handler对象
Bundle b = new Bundle();
b.putInt("age", 20);
b.putString("name", "Jhon");
msg.setData(b);
msg.sendToTarget(); //将msg发送到myHandler
}
//定义类，这里只是定义MyHandler一个类，并未和新线程相关起来
class MyHandler extends Handler{
public MyHandler(){
}
public MyHandler(Looper looper){
super(looper);
}
@Override
public void handleMessage(Message msg) {
Bundle b = msg.getData();
int age = b.getInt("age");
String name = b.getString("name");
System.out.println("age is " + age + ", name is" + name);
System.out.println("Handler--->" + Thread.currentThread().getId());
System.out.println("handlerMessage");
}
}
}
这样，当使用sendMessage方法传递消息或者使用post方法传递Runnable对象时，就会把它们传递到与handler对象绑定的处于另外一个线程的消息队列中，它们将在另外的消息队列中被处理。而主线程还会在发送操作完成时候继续进行，不会影响当前的操作。
这里需要注意，这里用到的多线程并非由Runnable对象开启的，而是ThreadHandler对象开启的。Runnable对象只是作为一个封装了操作的对象被传递，并未产生新线程。