Handler消息处理机制

  Android在设计时引入了Handler消息机制，每个消息发送到主线路的消息队列中，消息队列遵循先进先出原则，发送消息不会阻塞线程，而接收线程会阻塞线程。Handler容许发送并处理Message消息，Message对象经过主线程的MessageQueue消息队列相关联的Message和Runnable对象进行存取。每一个Handler实例对Message消息发送和接收与对应主线程和主线程的消息队列有关。当建立一个新的Handler时，Handler就属于当前主线程，主线程MessageQueue消息队列也同步建立，即Handler会绑定到建立该Handler的主线程/消息队列上。而后，Handler就能够经过主线程的消息队列发送和接收Message消息对象了。

Handler的特性

1）Android里没有全局Message Queue消息队列，每一个Activity主线程都有一个独立的Message Queue消息队列，消息队列采用先进先出原则。不一样APK应用不能经过Handler进行Message通讯，同一个APK应用中能够经过Handler对象传递而进行Message通讯。

2）每一个Handler实例都会绑定到建立它的线程中（通常位于主线程，即Activity线程），可是Handler实例能够在任意线程中建立（能够在主线程或子线程中建立）

3）Handler发送消息使用Message Queue消息队列，每一个Message发送到消息队列里面；发送消息采用异步方式，因此不会阻塞线程。而接收线程则采用同步方式，因此会阻塞线程，因此当Handler处理完一个Message对象后才会去取下一下消息进行处理。

  下面咱们经过一个实例来加深一下对以上内容的理解，在这个实现中，经过四个Button的onClick事件，实现不一样方式的Handler消息处理机制。

button_1：完成在主线程中传递Handler消息处理

button_2：在子线程中完成Handler消息处理

button_3：在其它线程完传入Handler对象并完成其消息处理

button_4：一个实验，验证在其它线程中更新ActivityUI时会抛出异常（这个我没实现，感兴趣的本身写吧）

话很少说，直接上源码吧

1）activity_main.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >
    <Button
        android:id="@+id/button_1"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="handle msg in main thread"/>
    <Button
        android:id="@+id/button_2"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="handle msg in sub thread"/>
    <Button
        android:id="@+id/button_3"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="handler comes from other thread"/>
    <Button
        android:id="@+id/button_4"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="refresh ActivityUI in other thread"/>
</LinearLayout>

2）MainActivity.java

package cn.lion.handlertest;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.Toast;
public class MainActivity extends Activity implements OnClickListener{
 private Button button1 = null;
 private Button button2 = null;
 private Button button3 = null;
 //private Button button4 = null;
 private MyHandler mHandler = null;
 private Message msg = null;
 
 @Override
 protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_main);
  button1 = (Button)findViewById(R.id.button_1);
  button2 = (Button)findViewById(R.id.button_2);
  button3 = (Button)findViewById(R.id.button_3);
  //button4 = (Button)findViewById(R.id.button_4);
  button1.setOnClickListener(this);
  button2.setOnClickListener(this);
  button3.setOnClickListener(this);
  //button4.setOnClickListener(this);
 }
 @Override
 public void onClick(View v) {
  dealOnClick(v.getId());  
 }
 /**
  * 自定义一个处理onClick事件的方法
  * @param msgId
  */
 private void dealOnClick(int msgId) {
  mHandler = new MyHandler(); //子线程和主线程均可以操做这个mHandler，固然也能够在switch的具体case中才建立
  
  switch(msgId){
  case R.id.button_1:
   // 主线程中建立MyHandler对象，mHandler建立Handler消息类型为一、消息对象为字符串的Message对象
   //mHandler = new MyHandler();
   msg = mHandler.obtainMessage(1, (Object)"Main thread send message by Message Object");
   msg.sendToTarget(); //Handler 发送消息
   break;
  case R.id.button_2:
   InnerThread innerThread = new InnerThread();
   innerThread.start(); //内部线程异步处理button_2的事件
   break;
  case R.id.button_3:
   //mHandler = new MyHandler();
   SubThread subThread = new SubThread(mHandler); //把主线程中建立的mHandler对象传递给子线程
   subThread.start(); //子线程对象，用于异步处理Handler Message消息
   break;   
  }  
 }
 
 /**
  * 自定义MyHandler，继承自Handler，覆盖父类的 handleMessage() 方法，msg.obj
  * 是Message对象传递过来的Object对象，本例中为String对象 。
  * @author lion
  *
  */
 public class MyHandler extends Handler{
  public MyHandler(Looper myLooper){
   super(myLooper);  //重写构造方法，经过Looper建立MyHandler对象
  }
  public MyHandler(){
   
  }
  @Override
  public void handleMessage(Message msg){
   String str = "";
   switch(msg.what){
   case 1:
    str = "1: " + msg.obj;
    break;
   case 2:
    str = "2: " + msg.obj;
    break;
   case 3:
    str = "3: " + msg.obj;
    break;
   }
   Toast toast = Toast.makeText(MainActivity.this, str, Toast.LENGTH_SHORT);
   toast.show();
  }
 }
 
 private class InnerThread extends Thread{
  @Override
  public void run(){
   
   //只能在Activity的主线程中使用不带Looper对象的构造函数来建立Handler对象，因此此行会抛出异常
   //mHandler = new MyHandler();
   
   //Lopper.myLooper()获取Looper为null，因此此行会抛出异常
   //mHandler = new MyHandler(Looper.myLooper());
   
   //经过Looper.getMainLooper()获取父类的looper能够成功建立Handler对象并将Message了送到父类
   mHandler = new MyHandler(Looper.getMainLooper());
   
   Message msg = mHandler.obtainMessage(2, (Object)"Inner thread send message by Message Object");
   msg.sendToTarget();
  }
 }
 
 /**
  * 子线程经过Handler对象建立Message对象，并在子线程中发送Handler消息，这个消息将由主线程在handleMessage中接收并响应
  * @author lion
  *
  */
 public class SubThread extends Thread{
  private Handler mHandler;
  public SubThread(Handler mHandler){
   this.mHandler = mHandler;
  }
  @Override
  public void run(){
   Message msg = mHandler.obtainMessage(3, (Object)"Other thread send message by myHandler");
   msg.sendToTarget();
  }
 }
}

  仔细分析一下Handler的做用：经过上面的实例能够看出，Handler的主要做用是异步处理较费时的操做，优先将界面返回给用户，异步处理完成后再去更新用户界面。在Android中启动应用程序时，Android首先会开启一个主线程（即UI线程），主线程专门管理界面中的UI控件，对事件进行分发，如点击一个Button，Android会分发事件到具体的Button上，以响应用户的操做。

  若是须要处理一个耗时的操做，以下载文件，那么这种操做就绝对不应放到主线程中进行，不然界面会出现假死现象。咱们要把这种耗时的操做放到子线程中去处理，子线程处理完成后再根据处理结果决定是否通知主线程更新UI，注意在子线程中是没法更新主线程的界面（UI）的。为了解决这个问题，Android引入了Handler，因为Handler运行在主线程中（即运行于Activity UI线程中），它与子线程能够经过Message对象来传递数据。因此能够利用Handler，从子线程中向主线程发送更新UI的消息，从而实现了UI的及时更新。

至于主线程和子线程如何通讯、Handler如何获取Message等问题，见我上篇文章 android的消息处理机制——Looper,Handler,Message