Android HandlerThread全面解析

在之前的一篇博客Android 异步消息处理机制：Looper、Handler、Message中，我们讲解了Looper、Handler、Message三者的关系。实际开发中我们使用的Looper基本都是定义在UI线程中，在子线程中通过handler.post(new Runnable())可以在UI线程中更新界面，这其实是UI线程在默默的为我们服务。
其实我们完全可以借鉴UI线程Looper的思想，搞个子线程Looper，也通过Handler、Message通信，可以适用于很多场景。
一个最标准的异步消息处理线程的写法应该是这样：

class LooperThread extends Thread {  
      public Handler mHandler;

      public void run() {  
          Looper.prepare();   
          mHandler = new Handler() {  
              public void handleMessage(Message msg) {  
                  // process incoming messages here  
              }  
          };
          Looper.loop();  
      }  
  } 

但是Android为我们提供了一个更方便的实现类—HandlerThread。

HandlerThread实例演示

这里的实例是用一个TextView显示当前时间，每隔2秒更新一次。

public class MainActivity extends Activity {
    private TextView text;
    private Button button;

    private HandlerThread mThread;
    private Handler mHandler;
    private boolean isUpdateInfo;
    private static final int MSG_UPDATE_INFO = 0x110;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        text = (TextView) findViewById(R.id.text);
        button = (Button) findViewById(R.id.start_service);
        //初始化HandlerThread       
        initBackThread();
    }

    @Override
    protected void onResume() {
        super.onResume();
        //开始更新
        isUpdateInfo = true;
        mHandler.sendEmptyMessage(MSG_UPDATE_INFO);
    }

    @Override
    protected void onPause() {
        super.onPause();
        //停止更新
        isUpdateInfo = false;
        mHandler.removeMessages(MSG_UPDATE_INFO);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        //释放资源
        mThread.quit();
    }

    private void initBackThread() {
        mThread = new HandlerThread("ActivityStartArguments");
        mThread.start();
        //注意这里Handler中传入的是HandlerThread的Looper
        mHandler = new Handler(mThread.getLooper()) {
            @Override
            public void handleMessage(Message msg) {
                //UI线程中更新界面
                runOnUiThread(new Runnable(){
                    @Override
                    public void run() {
                        text.setText(getCurrentTime());
                    }
                });
                //模拟耗时操作，等待2s
                try {
                    Thread.sleep(2000);
                } catch (Exception e) {
                    Thread.currentThread().interrupt();
                }
                //发送新的任务
                if (isUpdateInfo) {
                    mHandler.sendEmptyMessage(MSG_UPDATE_INFO);
                }
            }
        };
    } 

    public String getCurrentTime(){
        Date date = new Date();          
        DateFormat df = DateFormat.getTimeInstance(DateFormat.FULL);  
        String dateStr = df.format(date);  
        return dateStr;
    }

}

可以看到我们在onCreate中，去创建和启动了HandlerThread，并且关联了一个mThread。然后我们分别在onResume和onPause中去开启和暂停我们的任务，最后在onDestory中去释放资源。
这样就实现了每隔2s去更新我们的UI，当然我们这里通过Thread.sleep()模拟耗时，返回了当前时间，大家可以很轻易的换成真正的数据接口。
这里我们是在旧的Message处理完毕之后再发送新的Message给HandlerThread，其实这个过程可以是异步的，也就是说在旧的Message还没有处理完，新的Message就可以发送了，这时新的Message会存放在Looper的MessageQueue中，待旧的Message处理完毕后，然后Looper会不断从该MessageQueue中读取新的Message并处理。Looper当没有消息的时候会阻塞，有消息到来的时候就会唤醒。

运行看效果：

HandlerThread源码分析

首先看HandlerThread 启动的地方：

mThread = new HandlerThread("ActivityStartArguments");
mThread.start();

其实我们就是初始化和启动了一个线程，看HandlerThread内部构造：

public class HandlerThread extends Thread {
    int mPriority;
    int mTid = -1;
    Looper mLooper;

    public HandlerThread(String name) {
        super(name);
        mPriority = Process.THREAD_PRIORITY_DEFAULT;
    }

    protected void onLooperPrepared() {
    }

    @Override
    public void run() {
        mTid = Process.myTid();
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll();
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        Looper.loop();
        mTid = -1;
    }

来看run()方法，可以看到该方法中调用了Looper.prepare()，Loop.loop(); prepare()当中会创建一个Looper对象，并且把该对象放到了该线程范围内的变量中（sThreadLocal），在Looper对象的构造过程中，初始化了一个MessageQueue，作为该Looper对象成员变量。
loop()开启后，会不断的循环从MessageQueue中取消息处理，当没有消息的时候会阻塞，有消息的到来的时候会唤醒。

接下来，我们创建了一个mHandler，是这么创建的：

mHandler = new Handler(mThread.getLooper())

对应源码：

public Looper getLooper() {
        if (!isAlive()) {
            return null;
        }

        // If the thread has been started, wait until the looper has been created.
        synchronized (this) {
            while (isAlive() && mLooper == null) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }
        }
        return mLooper;
    }

mThread.getLooper()返回的就是我们在run方法中创建的mLooper。
那么Handler的构造呢，其实就是在Handler中持有一个指向该Looper.mQueue对象，当handler调用sendMessage方法时，其实就是往该mQueue中去插入一个message，然后Looper.loop()就会取出执行。

注：如果你够细心会发现，run方法里面当mLooper创建完成后有个notifyAll()，getLooper()中有个wait()，这是为什么呢？因为mLooper在一个线程中执行，而我们的handler是在UI线程初始化的，也就是说，我们必须等到mLooper创建完成，才能正确的返回getLooper();wait(),notify()就是为了解决这两个线程的同步问题。

HandlerThread结合Service使用

我们都知道在Service里面不能直接进行耗时操作，一般都需要去开启子线程去做一些事情，自己去管理Service的生命周期以及子线程并非是个优雅的做法；其实我们可以结合HandlerThread完成对Service生命周期的控制，非常完美。

public class MyService extends Service {
    private HandlerThread mThread;
    private Handler mHandler;

    @Override  
    public void onCreate() {  
        super.onCreate();  
        initBackThread();
    }  

    private void initBackThread() {
        mThread = new HandlerThread("ServiceStartArguments");
        mThread.start();
        mHandler = new Handler(mThread.getLooper()) {
            @Override
            public void handleMessage(Message msg) {
                //线程操作
                MainActivity.showlog("processing...msg.arg1="+msg.arg1);
                try {
                    Thread.sleep(2000);
                } catch (Exception e) {
                    Thread.currentThread().interrupt();
                }
                //和当前startId一致时，才销毁service
                stopSelf(msg.arg1);
            }
        };
    }

    @Override  
    public int onStartCommand(Intent intent, int flags, int startId) {          
        //执行新的任务，传入startId
        Message msg = mHandler.obtainMessage();
        msg.arg1 = startId;
        mHandler.sendMessage(msg);      
        return START_STICKY;
    }  

    @Override  
    public void onDestroy() {  
        super.onDestroy();
        MainActivity.showlog("onDestroy");
        mThread.quit();
    }  

    @Override  
    public IBinder onBind(Intent intent) {
        return null;
    }  

}  

启动Service：

    @Override  
    public void onClick(View v) {  
        switch (v.getId()) {  
        case R.id.start_service:
            showlog("click Start Service button");
            Intent it1 = new Intent(this, MyService.class);  
            startService(it1);  
            break;
        default:  
            break;  
        }  
    }  

当我们多次点击Start Service按钮，多次启动Service，onStartCommand执行多次，会发送多个Message到HandlerThread，然后Looper会不断从该MessageQueue中读取新的Message并处理。
关键点来了，执行完任务后有这么一句话，stopSelf(msg.arg1);，注意这个msg.arg1是个int值，相当于一个请求的唯一标识，其实它就是启动Service的startId，我们每次启动Service会把这个startId传到onStartCommand的第三个参数，并将它置为当前的启动ID。当调用stopSelf(msg.arg1)方法时，若该标识与当前的启动ID一致，则销毁service，如果在调用stopSelf(msg.arg1)之前，Service收到一个新的Start请求，ID将无法匹配，Service并不会停止。

我们看一下效果，启动程序，连续点击三次Start Service：

可以看到，处理了三次任务，每次间隔时间2s，最后一次处理完毕后，Service自动销毁。这样就自动完成了Service生命周期的控制，Service完全不需要我们自己手动去销毁。

其实所有这些过程，Android已经帮我们封装好了，Android已经给我们提供了一个现成类，叫做IntentService，下面看具体用法。

IntentService使用

使用IntentService的要点如下：

• 默认在子线程中处理回传到onStartCommand()方法中的Intent；
• 在重写的onHandleIntent()方法中处理按时间排序的Intent队列，所以不用担心多线程（multi-threading）带来的问题。
• 当所有请求处理完成后，自动停止service，无需手动调用stopSelf()方法； 默认实现了onBind()方法，并返回null；
• 默认实现了onStartCommand()方法，并将回传的Intent以序列的形式发送给onHandleIntent()，您只需重写该方法并处理Intent即可。

综上所述，您只需重写onHandleIntent()方法即可，当然，还需要创建一个构造方法，示例如下：

public class MyIntentService extends IntentService {        

    public MyIntentService() {
        super("MyIntentService");
    }

    @Override  
    public void onHandleIntent(Intent intent) {
        //线程操作
        MainActivity.showlog("processing...");
        try {
            Thread.sleep(2000);
        } catch (Exception e) {
            Thread.currentThread().interrupt();
        } 
    }

    @Override  
    public void onDestroy() {  
        super.onDestroy();
        MainActivity.showlog("onDestroy");
    }  

}  

是不是简单多了呢？其实效果和上面是一样的。如果你还希望在IntentService的继承类中重写其他生命周期方法，如onCreate()、onStartCommand() 或 onDestroy()，那么请先调用各自的父类方法以保证子线程能够正常启动。 比如，这里我重写了onDestroy()方法，添加了Log信息。
注：除onHandleIntent()外，onBind()方法也无需调用其父类方法。

连续点击三次Start Intent Service按钮，Log如下：

下面我们再稍微看下IntentService的源码：

public abstract class IntentService extends Service {
    private volatile Looper mServiceLooper;
    private volatile ServiceHandler mServiceHandler;
    private String mName;
    private boolean mRedelivery;

    private final class ServiceHandler extends Handler {
        public ServiceHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            onHandleIntent((Intent)msg.obj);
            stopSelf(msg.arg1);
        }
    }


    public IntentService(String name) {
        super();
        mName = name;
    }


    public void setIntentRedelivery(boolean enabled) {
        mRedelivery = enabled;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        thread.start();

        mServiceLooper = thread.getLooper();
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }

    @Override
    public void onStart(Intent intent, int startId) {
        Message msg = mServiceHandler.obtainMessage();
        msg.arg1 = startId;
        msg.obj = intent;
        mServiceHandler.sendMessage(msg);
    }


    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        onStart(intent, startId);
        return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
    }

    @Override
    public void onDestroy() {
        mServiceLooper.quit();
    }


    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }


    protected abstract void onHandleIntent(Intent intent);
}

可以看到它在onCreate里面初始化了一个HandlerThread，然后每次调用onStart的时候，通过mServiceHandler发送一个消息，消息中包含我们的intent。然后在该mServiceHandler的handleMessage中去回调onHandleIntent(intent);就可以了。果然是这样，onStartCommand中回调了onStart，onStart中通过mServiceHandler发送消息到该handler的handleMessage中去。最后handleMessage中回调onHandleIntent(intent)。回调完成后回调用 stopSelf(msg.arg1)，当任务完成销毁Service回调onDestory，可以看到在onDestroy中释放了我们的Looper:mServiceLooper.quit()。

Demo下载地址