Handler的定义:

　　主要接受子线程发送的数据, 并用此数据配合主线程更新UI。当应用程序启动时，

Android 首先会开启一个主线程 ( 也就是 UI 线程 ) , 主线程为管理界面中的 UI 控件，进行事件分发 , 比如说 ,

你要是点击一个 Button ,Android 会分发事件到 Button 上，来响应你的操作。

　  如果此时需要一个耗时的操作，例如: 联网读取数据，或者读取本地较大的一个文件的时候，你不能把这些操作放在主线程中，

如果你放在主线程中的话，界面会出现假死现象 , 如果 5 秒钟还没有完成的话，会收到 Android 系统的一个错误提示 " 强制关闭 "(FC) 。

　   这个时候我们需要把这些耗时的操作，放在一个子线程中，因为子线程涉及到UI更新，Android主线程是线程不安全的，

也就是说，更新 UI 只能在主线程中更新，子线程中操作是危险的。这个时候，我们就需要用Handler 来解决这个复杂的问题 。

　　由于Handler运行在主线程中(UI线程中)，它与子线程可以通过Message对象来传递数据,

这个时候， Handler 就承担着接受子线程传过来的 ( 子线程用 sedMessage() 方法传弟 )Message 对象 ( 里面包含数据 ) ，把这些消息放入主线程队列中，配合主线程进行更新 UI 。

　　Handler一些特点：

　　Handler可以分发Message对象和Runnable对象到主线程中, 每个Handler实例,都会绑定到创建他的线程中(一般是位于主线程),

  它有两个作用 : (1): 安排消息或 Runnable 在某个主线程中某个地方执行 , (2) 安排一个动作在不同的线程中执行

　　Handler中分发消息的一些方法：

　　post(Runnable)

　　postAtTime(Runnable,long)

　　postDelayed(Runnable,long)

　　sendEmptyMessage(int)

　  sendMessage(Message)

　　sendMessageAtTime(Message,long)

　　sendMessageDelayed(Message,long)

　　 以上post类方法允许你排列一个Runnable对象到主线程队列中,当需要在不同于主UI线程中执行则需要配合HandlerThread进行使用：

　　HandlerThread handlerThread = new HandlerThread("myHandlerThread");

　　handlerThread.start();

handler = new Handler(handlerThread.getLooper());

sendMessage类方法, 允许你安排一个带数据的Message对象到队列中，等待更新.

　　

1. import android.app.Activity;  
2. import android.os.Bundle;  
3. import android.os.Handler;  
4. import android.os.Looper;  
5. import android.os.Message;  
6. import android.view.View;  
7. import android.widget.Button;  
8. import android.widget.ProgressBar;  
9. import android.widget.TextView;  
10.  
11. public class HandlerActivity extends Activity {  
12.     private TextView textView;  
13.     private MyHandler myHandler;  
14.     private Button button;  
15.     private ProgressBar progressBar;  
16.     private MyThread m = new MyThread();  
17.  
18.     /** Called when the activity is first created. */  
19.     @Override  
20.     public void onCreate(Bundle savedInstanceState) {  
21.         super.onCreate(savedInstanceState);  
22.         setContentView(R.layout.main);  
23.         textView = (TextView) findViewById(R.id.text);  
24.         button = (Button) findViewById(R.id.startButton);  
25.         progressBar = (ProgressBar) findViewById(R.id.bar);  
26.         progressBar.setMax(100);  
27.         button.setOnClickListener(new View.OnClickListener() {  
28.             @Override  
29.             public void onClick(View arg0) {  
30.                 myHandler = new MyHandler();  
31.                 new Thread(m).start();  
32.                 System.out.println("onCreate--The Thread is: "  
33.                         + Thread.currentThread().getId());  
34.             }  
35.         });  
36.     }  
37.  
38.     // 在对UI进行更新时，执行时所在的线程为主UI线程  
39.     class MyHandler extends Handler {// 继承Handler类时，必须重写handleMessage方法  
40.         public MyHandler() {  
41.         }  
42.  
43.         public MyHandler(Looper l) {  
44.             super(l);  
45.         }  
46.  
47.         @Override  
48.         public void handleMessage(Message msg) {// 执行接收到的通知，此时执行的顺序是按照队列进行，即先进先出  
49.             System.out.println("Handler--The ThreadId is: "  
50.                     + Thread.currentThread().getId());  
51.             super.handleMessage(msg);  
52.             Bundle b = msg.getData();  
53.             String textStr0 = textView.getText().toString();  
54.             String textStr1 = b.getString("textStr");  
55.             HandlerActivity.this.textView.setText(textStr0 + " " + textStr1);// 更改TextView中的值  
56.             int bbarValue = b.getInt("barValue");  
57.             HandlerActivity.this.progressBar.setProgress(barValue);  
58.             ;// 更改进度条当中的值  
59.         }  
60.     }  
61.  
62.     // 该线程将会在单独的线程中运行  
63.     class MyThread implements Runnable {  
64.         int i = 1;  
65.         @Override  
66.         public void run() {  
67.             while(i<11){  
68.                 System.out.println("Thread--The ThreadId is: "  
69.                         + Thread.currentThread().getId());  
70.                 try {  
71.                     Thread.sleep(1000);  
72.                 } catch (InterruptedException e) {  
73.                     e.printStackTrace();  
74.                 }  
75.                 Message msg = new Message();  
76.                 Bundle b = new Bundle();  
77.                 b.putString("textStr", "线程运行" + i + "次");  
78.                 b.putInt("barValue", i * 10);  
79.                 i++;  
80.                 msg.setData(b);  
81.                 // 通过sendMessage向Handler发送更新UI的消息  
82.                 HandlerActivity.this.myHandler.sendMessage(msg);  
83.             }  
84.         }  
85.     }  
86. }