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下载地址

HandlerThread实例演示

HandlerThread源码分析

HandlerThread结合Service使用

IntentService使用

更多相关文章

随机推荐