HandlerThread 源码分析

Posted 2021-06-26 datian1234

本文基于 Android 9.0.0 的源代码

framework/base/core/java/andorid/os/HandlerThread.java

使用简介

在Handler源码分析中我们提到,在子线程中创建Handler,要手动调用Looper.prepare(),创建的过程大致如下

Handler mHandler;
private void createManualThreadWithHandler() {
  new Thread() {
      @Override
        public void run() {
            super.run();
            Looper.prepare();
            mHandler = new Handler(Looper.myLooper());
            Looper.loop();
        }
    }.start();
}

android为了简化Handler的创建过程提供了一个便捷的类，使用它我们可以快速的创建一个带有Looper的线程，有了Looper这个线程，我们就可以生成Handler。

如何使用

// Step 1: 创建并启动HandlerThread线程，内部包含Looper
HandlerThread handlerThread = new HandlerThread("lingdage");
handlerThread.start();

// Step 2: 创建Handler
Handler handler = new Handler(handlerThread.getLooper());

// Step 3: 发送消息
handler.post(new Runnable() {
        @Override
        public void run() {
            System.out.println("thread id="+Thread.currentThread().getId());
        }
});

源码分析

创建HandlerThread对象

public HandlerThread(String name) {
    super(name);
    //HandlerThread的默认优先级是Process.THREAD_PRIORITY_DEFAULT,具体值为0。
    mPriority = Process.THREAD_PRIORITY_DEFAULT;
}

public HandlerThread(String name, int priority) {
    super(name);
    mPriority = priority;
}

线程的优先级的取值范围为-20到19。优先级高的获得的CPU资源更多，反之则越少。-20代表优先级最高，19最低。0位于中间位置，但是作为工作线程的HandlerThread没有必要设置这么高的优先级，因而需要我们降低其优先级。注意！是Process里的优先级而不是Thread的。

可控制的优先级

• THREAD_PRIORITY_DEFAULT，默认的线程优先级，值为0。

• THREAD_PRIORITY_LOWEST，最低的线程级别，值为19。

• THREAD_PRIORITY_BACKGROUND 后台线程建议设置这个优先级，值为10。

• THREAD_PRIORITY_MORE_FAVORABLE 相对THREAD_PRIORITY_DEFAULT稍微优先，值为-1。

• THREAD_PRIORITY_LESS_FAVORABLE 相对THREAD_PRIORITY_DEFAULT稍微落后一些，值为1。

  以上的这些优先级都是可以在程序中设置的，除此之外还有不可控的优先级均有系统进行自动调整。

  常见的加入优先级的方法如下

Runnable run = new Runnable() {
  @Override
  public void run() {
      android.os.Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
  }
};

关于Android中线程的调度详情，请参考剖析Android中进程与线程调度之nice

获取Looper

/**
     * This method returns the Looper associated with this thread. If this thread not been started
     * or for any reason isAlive() returns false, this method will return null. If this thread
     * has been started, this method will block until the looper has been initialized.  
     * @return The looper.
     */
public Looper getLooper() {
    //使用handlerThread 要先start
    if (!isAlive()) {
        return null;
    }

    // If the thread has been started, wait until the looper has been created.
    synchronized (this) {
        while (isAlive() && mLooper == null) { // 进入同步块，当条件不满足时无限等待，
            try { // 直到mLooper被设置成有效值了才退出while（当然也可能是线程状态不满足）；
                wait();  // run方法里的notifyAll就是用来唤醒这里的
            } catch (InterruptedException e) {
            }
        }
    }
    return mLooper;
}

这个方法比较简单，直接看官方的注释就明白了。

执行HandlerThread的run()

public void run() {
    mTid = Process.myTid();  //获取线程的tid
    Looper.prepare();   // 创建Looper对象
    synchronized (this) {
        mLooper = Looper.myLooper(); //获取looper对象
        notifyAll(); //唤醒等待线程
    }
    Process.setThreadPriority(mPriority);
    onLooperPrepared();  // 重写 onLooperPrepared，做一些初始化工作
    Looper.loop();   //loop方法是阻塞的 在未执行quit()或quitSafely()的时候后面代码是不执行的
    mTid = -1;
}

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()与quitSafely()的区别，仅仅在于是否移除当前正在处理的消息。移除当前正在处理的消息可能会出现不安全的行为。

使用场景

总结之前，我们先想一个场景，如果我们现在需要请求网络数据(假设需要请求一张图片,图片请求返回后需要更新UI),我们都知道UI线程中不允许进行耗时的网络请求。那么，我们通常会开启一个子线程来进行请求,如果你不用网络请求的三方库，一般会通过new Thread(),然后start()来完成吧！这样的话，如果有多次请求图片，那么我们就得new 很多个Thread。所以这是个问题！！！

问题解决分析 通过上面代码我们知道：HandlerThread一个子线程，并且含有一个Looper。 再来看看那个问题：我们之所以需要new Thread(),然后start().是因为UI线程无法进行网络请求，但是，HandlerThread可是一个子线程，所以，在它里面可以直接请求网络，于是上面的new Thread()然后start()问题就解决了。 当然，就凭他是个子线程还没法说服我，虽然它是一个子线程不需要new Thread()，但是它自己也可能需要多次创建啊！只不过是从new一个Thread变成了new HanderThread()而已。这还不是没卵用。

那么如何解释它不需要重复创建呢？ 其实也不难，只需要子线程不结束不就行了。(run方法中加个while(true)啊)，不过，它这里并不是while(true),而是用到了调用了一个loop()方法。

loop方法是阻塞的，所以它后面的语句在它未退出的（可以通过quit()方法和quitSafely()方法退出）时候是没办法执行的。再加上它可以通过在外部实现一个Handler，然后，通过这个Handler给Looper发送message，近而源源不断的实现网络请求。所以，这就真正的解决了上面提出的那个问题。 这里给一个连接，里面介绍了如何在外部创建一个Handler,然后源源不断进行网络请求。 Android 多线程之HandlerThread 完全详解

总结

HandlerThread所做的就是在新开的子线程中创建了 Looper，那它的使用场景就是 Thread+Looper使用场景的结合，即：在子线程中执行耗时的、可能有多个任务的操作。

HandlerThread比较适用于单线程+异步队列的场景，比如IO读写操作，耗时不多而且也不会产生较大的阻塞。对于网络IO操作，HandlerThread并不适合，因为它只有一个线程，还得排队一个一个等着。

对于本地IO读取操作，我们可以使用postAtFrontOfQueue方法，快速将读取操作加入队列前端执行，必要时返回给主线程更新UI。示例场景，从数据库中读取数据展现在ListView中。注意读取也是需要花费一定时间，推荐在数据展示之前有必要的用户可感知进度提示。