HandlerThread原理与应用

2019年6月7日 175次阅读 来源: 小码匠

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就能完美的解决此需求。
    原文作者：小码匠
    原文地址: https://www.jianshu.com/p/d5b59278596e
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞