HandlerThread原理与应用

HandlerThread


 在理解了Handler的原理之后,我们知道在一个子线程中创建一个Handler不能缺少了Looper.prepare()和Looper.loop()两个方法,具体的原因这里不再赘述,不熟悉原理的可以先看下另一篇文章Handler的原理解析.
本篇文章主要是讲解HandlerThread的使用的。
 首先HandlerThread是继承于Thread类的,所以本质上HandlerThread就是一个线程,接下来就详细的去看一看,这是怎样的一个线程?
 首先,先看下它的构造函数:

public HandlerThread(String name) {
        super(name);
        mPriority = Process.THREAD_PRIORITY_DEFAULT;
    }
public HandlerThread(String name, int priority) {
        super(name);
        mPriority = priority;
    }
//很简单,构造函数里只是设置了该Thread的名称和优先级。

 既然是线程,那么最重要的当然是run方法来,看完了run方法,相信你也就明白HandlerThread的用途了!

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

 怎么样,这是不是和我们之前在子线程中创建Handler一样,首先是Looper.prepare(),接着是new Handler(), 最后是Looper.loop()。等等,这里并没有创建Handler啊!别急,我们先一步一步地看看run方法再说为什么没有创建Handler。

  1. 首先呢是调用了Looper.prepaer(),该方法为我们的线程创建了一个唯一的Looper和MessageQueue对象,具体的创建过程看另一篇文章Handler的原理解析
  2. 接下来有一个同步锁的代码块,里面获取到了创建好的Looper对象将其赋值给当前的mLooper,然后唤醒了锁。注意这里有一个唤醒线程的操作,既然有唤醒锁的操作,那么必定有有个地方使线程处于了阻塞的状态,我们看下出现阻塞的地方。
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;
    }

 通过查找发现到一个getLooper()的方法,该方法返回了当前线程的mLooper对象,还记得Looper是在哪里进行赋值的吗?在线程的run方法里,所以当线程启动之后才能创建Looper并赋值给mLooper,这里的阻塞就是为了等待Looper的创建成功。同时该方法是用Public修饰的,说明该方法是提供外部调用的,Looper创建成功提供给外部使用。

  1. 接着我们回到run方法,Looper和MessageQueue已经创建成功了,接下来就是启动Looper循环了(即Looper.loop()),别忘了只有Looper循环启动后我们才能时刻观察着MessageQueue,只要有Message了才能立马将Message取出来进行分发处理。
  2. 在Looper.loop()之前还调用了一个onLooperPrepared()方法,这个方法是干嘛的呢? 看代码可知,只是一个空方法,在使用HandlerThread时重写该方法,方便在Looper轮询消息之前做一些初始化的操作。
/**
    * Call back method that can be explicitly overridden if needed to execute some
    * setup before Looper loops.
    */
   protected void onLooperPrepared() {
   }

 最后在对象销毁前,调用下面的方法退出Looper循环

public boolean quit() {
        Looper looper = getLooper();
        if (looper != null) {
            looper.quit();
            return true;
        }
        return false;
    }
public boolean quitSafely() {
        Looper looper = getLooper();
        if (looper != null) {
            looper.quitSafely();
            return true;
        }
        return false;
    }

 quit方法实际是调用MessagQueue的removeAllMessagesLocked,移除所有延迟和非延迟的消息,
 quitSafely方法调用的是removeAllFutureMessagesLocked方法,该方法只清除延迟的消息,非延迟的消息
还是会进行分发处理。


 HandlerThread分析完啦,是不是有点蒙,自始至终都没有出现Handler,HandlerThread要怎么用呢?
 下面我们就通过一个Demo来说明下HandlerThread是怎么用的?

private WorkHandler mHandler;
    private HandlerThread mHandlerThread;
    /*Handler存在一个构造函数,传入一个Looper对象,Handler的handleMessage获取的是Looper的MessageQueue中的Message
      因此,handleMessage的调用与Looper对象同属于一个线程,这里我们在构造时传入HandlerThread的Looper对象,
      handleMessage运行于HandlerThread线程(也就是一个子线程),所以Handler虽然是在住线程创建,但是它的
      handleMessage接收到消息是在HandlerThread线程,执行下代码可以看到打印出如下log:
      D/HandlerThreadDemo: HandlerThread/Demo thread receiver the message from thread: main
      log也说明,message由主线程传递到了HandlerThread中。
    */
    private class WorkHandler extends Handler {
        WorkHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            String str = (String) msg.obj;
            Log.d(TAG, Thread.currentThread().getName() + " thread receiver the message from thread: " + msg.obj);
        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_handlerthread_demo);
        mHandlerThread = new HandlerThread("HandlerThread/Demo");
        mHandlerThread.start();
        mHandler = new WorkHandler(mHandlerThread.getLooper());
        Message msg = mHandler.obtainMessage();
        msg.obj = Thread.currentThread().getName();
        mHandler.sendMessage(msg);
        
    }

总结:

  1. HandlerThread继承于Thread,本质上也是一个线程。
  2. HandlerThread的run方法为本线程创建提供了Looper和MessageQueue对象,并开启了Looper轮询消息。
  3. 通过在需要发送Message的线程中创建Handler,为Handler提供来自HandlerThread的Looper对象。Handler则能
    将消息发送到HandlerThread上去进行处理。
    注意:这里Handler不仅仅能在主线程创建,在子线程同样能够创建,只需要将对应的Looper提供给Handler即可,所以HandlerThread
    不仅适用于和主线程通信,同样适用于和其他子线程通信。
  4. 最后需要注意的是在我们不需要这个looper线程的时候需要手动停止掉,即调用quit()或者quitSafely()。
  5. 最后补充一个在实际开发过程中使用到HandlerThread的场景:
    存在多个耗时的任务需要放到开启子线程依次去处理(串行处理任务),首先,HandlerThread是一个子线程,
    适合处理耗时的任务,其次,Handler分发消息是通过MessageQueue顶部的Message不断的通过Message的next依次取出
    Message,符合任务的按顺序串行处理的要求,所以使用HandlerThread就能完美的解决此需求。
上一篇:RecyclerView 性能优化 | Android offer 收割机


下一篇:iOS中动态更新补丁策略JSPatch运用基础一