android开发教程之handle实现多线程和异步处理

这次浅谈一下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，可以实现与主线程的分离，从而可以实现多线程和异步处理。