Android开发学习笔记(8)：浅谈Handler实现多线程和异步处理

这次浅谈一下Handler,为什么会出现Handler这个功能特性呢？首先，在之前的基本控件，基本都是在Activity的onCreate(Bundle savedInstanceState)方法中调用和处理的，但是，在有些情况，比如在网络上下载软件等一些需要等待响应时间比较长的操作，如果同样放在Activity的该方法中的话，那么在执行该方法的时候，整个Activity是不可动的，用户只能干等着，这样的用户体验是十分差的，这种处理方式带来的最好结果是等待了一段时间后，得到了想要的结果，不好的情况就是等了N久，也没有出现结果，有的甚至会使Activity报错，为了避免这些情况的发生，所以引入了Handler的特性，他就像是一个线程队列，它也是一种异步的消息处理。

首先我们先看一个例子，通过例子来对 Handler进行认识。

布局文件中是两个按钮，分别是 start和stop，分别控制线程的开始和停止。

 

  
  
  
  

   
   
   
   
<Button  
   
   
   
   
    android:id="@+id/start" 
   
   
   
   
    android:layout_height="wrap_content" 
   
   
   
   
    android:layout_width="fill_parent" 
   
   
   
   
    android:text="@string/start" 
   
   
   
   
/> 
   
   
   
   
<Button  
   
   
   
   
    android:id="@+id/stop" 
   
   
   
   
    android:layout_height="wrap_content" 
   
   
   
   
    android:layout_width="fill_parent" 
   
   
   
   
    android:text="@string/stop" 
   
   
   
   
/> 
  
  
  
  

 

在 Activity中的代码如下：

 

  
  
  
  

   
   
   
   
import android.app.Activity; 
   
   
   
   
import android.os.Bundle; 
   
   
   
   
import android.os.Handler; 
   
   
   
   
import android.view.View; 
   
   
   
   
import android.view.View.OnClickListener; 
   
   
   
   
import android.widget.Button; 
   
   
   
   
 
   
   
   
   
public class HandlerDemo1Activity extends Activity { 
   
   
   
   
    Button startButton = null; 
   
   
   
   
    Button endButton = null; 
   
   
   
   
    Handler handler = new Handler(); 
   
   
   
   
    /** Called when the activity is first created. */ 
   
   
   
   
    @Override 
   
   
   
   
    public void onCreate(Bundle savedInstanceState) { 
   
   
   
   
        super.onCreate(savedInstanceState); 
   
   
   
   
        setContentView(R.layout.main); 
   
   
   
   
        startButton = (Button)findViewById(R.id.start); 
   
   
   
   
        startButton.setOnClickListener(new StartListener()); 
   
   
   
   
        endButton = (Button)findViewById(R.id.end); 
   
   
   
   
        endButton.setOnClickListener(new EndListener()); 
   
   
   
   
    } 
   
   
   
   
     
   
   
   
   
    class StartListener implements OnClickListener{ 
   
   
   
   
 
   
   
   
   
        @Override 
   
   
   
   
        public void onClick(View arg0) { 
   
   
   
   
            // TODO Auto-generated method stub 
   
   
   
   
            handler.post(HandlerThread); 
   
   
   
   
        } 
   
   
   
   
         
   
   
   
   
    } 
   
   
   
   
     
   
   
   
   
    class EndListener implements OnClickListener{ 
   
   
   
   
        @Override 
   
   
   
   
        public void onClick(View arg0) { 
   
   
   
   
            // TODO Auto-generated method stub 
   
   
   
   
            handler.removeCallbacks(HandlerThread); 
   
   
   
   
        } 
   
   
   
   
         
   
   
   
   
    } 
   
   
   
   
     
   
   
   
   
    Runnable HandlerThread = new Runnable() { 
   
   
   
   
         
   
   
   
   
        @Override 
   
   
   
   
        public void run() { 
   
   
   
   
            // TODO Auto-generated method stub 
   
   
   
   
            System.out.println("HandlerThread is Running......"); 
   
   
   
   
            handler.postDelayed(HandlerThread, 3000); 
   
   
   
   
        } 
   
   
   
   
    }; 
   
   
   
   
} 
  
  
  
  

 

我们可以看到，在 Activity中对两个按钮分别绑定了事件监听器，还创建了Handler的一个实例，以及创建了一个匿名内部类，是一个实现Runnable接口的线程HandlerThread。
 

当 start按钮按下时，即会执行handler.post(HandlerThread);这一句代码，之前说过，Handler用一个线程队列，这句代码即是把HandlerThread这个线程加入了handler的线程队列中，因为加入的这个HandlerThread是第一个线程，因此它会马上执行它的run()方法。在run()方法中，handler.postDelayed(HandlerThread, 3000);又再一次将HandlerThread放入handler的线程队列中，这里设置了3000ms的延迟。这样，整个程序会不断地运行，且每隔3000ms在LogCat中打印出"HandlerThread is Running......"。

 

但是，值得注意的是，不要以为现在 handler的出现，使得这些打印操作所在的线程和主线程分开了，其实不然，这里根本没有两个线程在跑，这些打印出来的内容，也是主线程跑出来的。我们可以做个试验，在onCreate函数之后以及打印语句的地方把当前的Thread的名字通过Thread.currentThread.getName()打印出来，可以看到，都是相同的，都是main，这就意味着都是主线程跑出来的。我们知道一个线程的启动需要start()方法，而在这个程序中并没有对HandlerThread进行start，而是直接调用了run()方法了。所以只是main线程在跑就不足为奇了。
 

从上面的例子来看，这个 Handler如果这样用的话，并不是我们想要的效果，因为它没有实现异步，还是在一个主线程中运行。
 

因此，我们必须换一种方式来使用 Handler。

要实现 Handler的异步多线程，就需要了解另两个类，一个是Message类，另一个是Looper类。

每个 Handler对象中都有一个消息队列，队列中就是存放的Message对象，可以使用obtainMessage()来获得消息对象。同时，Message对象是用来传递使用的，它能传递两个整型和一个Object，尽量使用Message的arg1与arg2两个整型来传递参数，那样系统消耗最小（API如是说）,如果传递数据量比较大，则可以使用setData(Bundle a)的方法，其中的Bundle对象可以粗略的看成是一个Map对象，但它的Key都是String，而value是有限的一些类型，可以再API里查看。
 

Looper类有能够循环地从消息队列中取得消息的功能，我们可以在一个线程中使用 Looper，这样，该线程就可以循环的在消息队列里取得消息，知道消息队列为空为止。但我们一般不直接创建和使用Looper，在Android提供的HandlerThread类中，就实现了Looper的功能，所以我们只要使用HandlerThread这个类就可以了，我们用HandlerThread的对象调用getLooper()来得到该线程的Looper对象。
 

我们来看下面这个例子

 

 

  
  
  
  

   
   
   
   
import android.app.Activity; 
   
   
   
   
import android.os.Bundle; 
   
   
   
   
import android.os.Handler; 
   
   
   
   
import android.os.HandlerThread; 
   
   
   
   
import android.os.Looper; 
   
   
   
   
import android.os.Message; 
   
   
   
   
 
   
   
   
   
public class HandlerDemo2Activity extends Activity { 
   
   
   
   
    /** Called when the activity is first created. */ 
   
   
   
   
    @Override 
   
   
   
   
    public void onCreate(Bundle savedInstanceState) { 
   
   
   
   
        super.onCreate(savedInstanceState); 
   
   
   
   
        setContentView(R.layout.main); 
   
   
   
   
        System.out.println("Activity---->"+Thread.currentThread().getName()); 
   
   
   
   
        HandlerThread handlerThread = new HandlerThread("HandlerThread");//创建一个HandlerThread对象，它是一个线程 
   
   
   
   
        handlerThread.start();//启动线程 
   
   
   
   
         
   
   
   
   
        MyHandler myHandler = new MyHandler(handlerThread.getLooper());//创建一个MyHandler对象，该对象继承了Handler，从下面的MyHandler类中可以看到，调用的是Handler父类的Handler(Looper looper)的构造函数，而这里传进去的Looper对象是从HandlerThread中取得的。 
   
   
   
   
        Message msg = myHandler.obtainMessage();//获得消息对象 
   
   
   
   
        msg.sendToTarget();//把得到的消息对象发送给生成该消息的Handler，即myHandler，当myHandler接收到消息后，就会调用其handleMessage的方法来处理消息 
   
   
   
   
    } 
   
   
   
   
     
   
   
   
   
    class MyHandler extends Handler{ 
   
   
   
   
        public MyHandler() {//构造函数 
   
   
   
   
            // TODO Auto-generated constructor stub 
   
   
   
   
        } 
   
   
   
   
         
   
   
   
   
        public MyHandler(Looper looper){//构造函数 
   
   
   
   
            super(looper);//实现了父类的该构造函数 
   
   
   
   
        } 
   
   
   
   
         
   
   
   
   
        @Override 
   
   
   
   
        public void handleMessage(Message msg) {//当这个Handler接收到Message对象的时候，会自动调用这个方法，来对Message对象进行处理 
   
   
   
   
            // TODO Auto-generated method stub 
   
   
   
   
            System.out.println("Handler---->"+Thread.currentThread().getName()); 
   
   
   
   
        } 
   
   
   
   
    } 
   
   
   
   
} 
  
  
  
  

 

上面的代码在 LogCat中System.out的执行结果为：

Acitivity---->main

Handler---->HandlerThread

这就说明了，使用 Handler，结合Looper和Message，可以实现与主线程的分离，从而可以实现多线程和异步处理。

以上只是个人浅谈Handler，附件是两个例子的代码，仅供参考。