一、handler的引入：
我们都知道，Android UI是线程不安全的，如果在子线程中尝试进行UI操作，程序就有可能会崩溃。相信大家在日常的工作当中都会经常遇到这个问题，解决的方案应该也是早已烂熟于心，即创建一个Message对象，然后借助Handler发送出去，之后在Handler的handleMessage()方法中获得刚才发送的Message对象，然后在这里进行UI操作就不会再出现崩溃了
private Handler handler = new Handler() {
18 public void handleMessage(Message msg) {
19 switch (msg.what) {
20 case UPDATE_TEXT:
21 text.setText("Nice to meet you");
22 break;
23 default:
24 break;
25 }
26 }
27 };
new Thread(new Runnable() {
43 @Override
44 public void run() {
45 Message message = new Message();
46 message.what = UPDATE_TEXT;
47 handler.sendMessage(message);
48 }
49 }).start();
上方第45行代码，官方建议我们写成：（这样的话，可以由系统自己负责message的创建和销毁）
Message msg = handler.obtainMessage();
或者写成：
Message msg = Message.obtain();上面的代码中，我们并没有在子线程中直接进行UI操作，而是创建了一个Message对象，并将它的what字段的值指定为了一个整形常量UPDATE_TEXT，用于表示更新TextView这个动作。然后调用Handler的sendMessage()方法将这条Message发送出去。很快，Handler就会收到这条Message，并在handleMessage()方法，在这里对具体的Message进行处理（需要注意的是，此时handleMessage()方法中的代码是在主线程中运行的）。如果发现Message的what字段的值等于UPDATE_TEXT，就将TextView显示的内容更新。运行程序后，点击按钮，TextView就会显示出更新的内容。
注：如果从源码的角度理解，粗略的描述是这样的：
先是调用了handler的obtainMessage()方法得到Message对象。在obtainMessage()方法里做的事情是：调用了Message.obtain(this)方法，把handler作为对象传进来。在Message.obtain(this)方法里做的事情是：生成message对象，把handler作为参数赋值给message的target属性。总的来说，一个Handler对应一个Looper对象，一个Looper对应一个MessageQueue对象，使用Handler生成Message，所生成的Message对象的Target属性，就是该对象。而一个Handler可以生成多个Message，所以说，Handler和Message是一对多的关系。
Android官网总结的关于Handler类的两个主要用途：
(1)执行定时任务：
指定任务时间，在某个具体时间或某个时间段后执行特定的任务操作，例如使用Handler提供的postDelayed(Runnable r,long delayMillis)方法指定在多久后执行某项操作，比如当当、淘宝、京东和微信等手机客户端的开启界面功能，都是通过Handler定时任务来完成的。
我们接下来讲一下post。
(2)线程间的通信：
在执行较为耗时的操作时，Handler负责将子线程中执行的操作的结果传递到UI线程，然后UI线程再根据传递过来的结果进行相关UI元素的更新。(上面已有说明)
// 声明一个Handler对象
14 private static Handler handler=new Handler();
//使用post方式
// 新启动一个子线程
29 new Thread(new Runnable() {
30 @Override
31 public void run() {
32 // tvMessage.setText("...");
33 // 以上操作会报错，无法再子线程中访问UI组件，UI组件的属性必须在UI线程中访问
34 // 使用post方式修改UI组件tvMessage的Text属性
35 handler.post(new Runnable() {
36 @Override
37 public void run() {
38 tvMessage.setText("使用Handler.post在工作线程中发送一段执行到消息队列中，在主线程中执行。");
39 }
40 });
41 }
42 }).start();
//使用postDelayed方式
// 新启动一个子线程
new Thread(new Runnable() {
51 @Override
52 public void run() {
53 // 使用postDelayed方式修改UI组件tvMessage的Text属性值
54 // 并且延迟3S执行
55 handler.postDelayed(new Runnable() {
56
57 @Override
58 public void run() {
59 tvMessage.setText("使用Handler.postDelayed在工作线程中发送一段执行到消息队列中，在主线程中延迟3S执行。");
60
61 }
62 }, 3000);
63 }
64 }).start();
65 注意的是：对于Post方式而言，它其中Runnable对象的run()方法的代码（37行至39行或者58至61行），均运行在主线程上（虽然看上去是写在子线程当中的），如果我们在这段代码里打印日志输出线程的名字，会发现输出的是Main Thread的名字。所以对于这段代码而言，不能执行在UI线程上的操作，一样无法使用post方式执行，比如说访问网络。
通过Handler实现线程间通信：
1、在Worker Thread发送消息，在MainThread中接收消息：
【实际意义】点击按钮时，程序访问服务器，服务器接到请求之后，会返回字符串结果，然后更新到程序。
package com.example.test0207_handler;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;
public class MainActivity extends Activity {
private TextView textView ;
private Button button ;
private Handler handler ;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
textView = (TextView)findViewById(R.id.TextViewId) ;
button = (Button)findViewById(R.id.ButtonId) ;
handler = new MyHandler() ;
button.setOnClickListener(new ButtonListener()) ;
}
//在MainAthread线程中接收数据，从而修改TextView的值
class MyHandler extends Handler {
@Override
public void handleMessage(Message msg) {
System.out.println("handleMessage--->"+Thread.currentThread().getName()) ;//得到当前线程的名字
String s = (String)msg.obj ;
textView.setText(s) ;
}
}
//生成线程对象，让NetworkThread线程启动
class ButtonListener implements OnClickListener {
@Override
public void onClick(View arg0) {
Thread t = new NetworkThread() ;
t.start();
}
}
//在Worker Thread线程中发送数据
class NetworkThread extends Thread {
@Override
public void run(){
System.out.println("network--->"+Thread.currentThread().getName()) ;//得到当前线程的名字
//模拟访问网络：当线程运行时，首先休眠2秒钟
try {
Thread.sleep(2*1000) ;
} catch (InterruptedException e) {
e.printStackTrace();
}
//变量s的值，模拟从网络当中获取的数据
String s = "从网络中获取的数据" ;
//textView.setText(s) ; //这种做法是错误的，只有在Mainthread中才能操作UI
//开始发送消息
Message msg = handler.obtainMessage() ;
msg.obj = s ;
handler.sendMessage(msg) ;//sendMessage()方法，在主线程或者Worker Thread线程中发送，都是可以的，都可以被取到
}
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.main, menu);
return true;
}
}这段代码的结构，和最上面的第一章节是一样的。
上方代码中，我们在子线程中休眠2秒来模拟访问网络的操作。
65行：用字符串s表示从网络中获取的数据；70行：然后我们把这个字符串放在Message的obj属性当中发送出去，并在主线程中接收（36行）。
运行后结果如下：
点击按钮后结果如下：
点击按钮后，后台输出结果如下：
可以看到，子线程的名字是：Thread-1118，主线程的名字是：main。
2、在MainThread中发送消息，在Worker Thread中接收消息：
【实例】点击按钮，在在MainThread中发送消息，在Worker Thread中接收消息，并在后台打印输出。
package com.example.m03_handle01;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
public class MainActivity extends Activity {
private Button button ;
private Handler handler ;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
button = (Button)findViewById(R.id.ButtonId) ;
//当用户点击按钮时，发送Message的对象msg
button.setOnClickListener(new OnClickListener() { //使用匿名内部类为button绑定监听器
@Override
public void onClick(View v) {
Log.i("onClick:", Thread.currentThread().getName());
Message msg = handler.obtainMessage() ;
handler.sendMessage(msg) ;
}
}) ;
WorkerThread wt = new WorkerThread() ;
wt.start() ;
}
//在WorkerThread生成handler
class WorkerThread extends Thread {
@Override
public void run() {
//准备Looper对象
Looper.prepare() ;
//在WorkerThread当中生成一个Handler对象
handler = new Handler() {
@Override
public void handleMessage(Message msg) {
Log.i("handleMessage:", Thread.currentThread().getName());
Log.i("后台输出", "收到了消息对象");
}
};
//调用Looper的loop()方法之后，Looper对象将不断地从消息队列当中取出对象，然后调用handler的handleMessage()方法，处理该消息对象
//如果消息队列中没有对象，则该线程阻塞
Looper.loop() ; //通过Looper对象将消息取出来
}
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.main, menu);
return true;
}
}上方的第42行至54行代码：这是MainThread中发送消息，在Worker Thread中接收消息的固定写法。上面的三个步骤再重复一下：
- 准备Looper对象
- 在WorkerThread当中生成一个Handler对象
- 调用Looper的loop()方法之后，Looper对象将不断地从消息队列当中取出对象，然后调用handler的handleMessage()方法，处理该消息对象；如果消息队列中没有对象，则该线程阻塞
注意，此时handleMessage()方法是在Worker Thread中运行的。
运行程序后，当我们点击按钮，就会在后台输出“收到了消息对象”这句话：
小小地总结一下：
首先执行Looper的prepare()方法，这个方法有两个作用：一是生成Looper对象，而是把Looper对象和当前线程对象形成键值对（线程为键），存放在ThreadLocal当中，然后生成handler对象，调用Looper的myLooper()方法，得到与Handler所对应的Looper对象，这样的话，handler、looper 、消息队列就形成了一一对应的关系，然后执行上面的第三个步骤，即Looper在消息队列当中循环的取数据。