Connor学Android - HandlerThread和IntentService

Learn && Live

虚度年华浮萍于世，勤学善思至死不渝

前言

Hey，欢迎阅读Connor学Android系列，这个系列记录了我的Android原理知识学习、复盘过程，欢迎各位大佬阅读斧正！原创不易，转载请注明出处：http://t.csdn.cn/cqCub，话不多说我们马上开始！

1.HandlerThread

1.1 定义

一个 Android 已封装好的轻量级异步类

1.2 作用

（1）实现多线程，可以在工作线程中执行一些耗时任务

（2）异步通信、消息传递，可以实现工作线程 & 主线程之间的通信，保证线程安全

（3）HandlerThread 在 Android 中的一个具体的使用场景是 IntentService

1.3 优点

方便实现异步通信，即不需使用任务线程（如继承 Thread 类） + Handler 的复杂组合

1.4 工作原理

内部原理 = Thread 类 + Handler 类机制，即：

• 通过继承 Thread 类，能够快速创建1个带有 Looper 对象的新工作线程
• 通过封装 Handler 类，快速创建 Handler 与其他线程进行通信

1.5 使用步骤

（1）HandlerThread 的本质：继承 Thread 类 & 封装 Handler 类

（2）HandlerThread`的使用步骤分为 5 步：

• 创建 HandlerThread 实例对象

• 调用 start 方法启动线程

• 通过 HandlerThread 的 Looper 对象创建 Handler 对象，并重写 handleMessage 方法用于处理接收到的消息

• 使用工作线程Handler向工作线程的消息队列发送消息

  • 定义要发送的 Message 信息
  • send 方法发送

• 调用 quit 方法结束线程，即停止线程中的消息循环

1.6 源码分析

分析过程按上述使用步骤

步骤1 创建 HandlerThread 实例对象

（1）HandlerThread 继承自 Thread

（2）主要变量

• int mPriority：线程优先级
• int mTid：当前线程 id
• Looper mLooper：当前线程持有的 Looper

（3）共有两个构造方法，创建的过程主要是创建一个指定线程名的工作线程 + 设置线程的优先级

• 第一个构造方法只指定线程名，优先级为默认优先级
• 另一个构造方法可以指定线程名和线程优先级

public class HandlerThread extends Thread {
    int mPriority;
    int mTid = -1;
    Looper mLooper;
    private @Nullable Handler mHandler;

    public HandlerThread(String name) {
        super(name);
        mPriority = Process.THREAD_PRIORITY_DEFAULT;
    }
    
    /**
     * Constructs a HandlerThread.
     * @param name
     * @param priority The priority to run the thread at. The value supplied must be from 
     * {@link android.os.Process} and not from java.lang.Thread.
     */
    public HandlerThread(String name, int priority) {
        super(name);
        mPriority = priority;
    }
    ...
}

步骤2 启动线程

（1）启动时调用的是父类，也就是 Thread 类的 start 方法，最终会回调 HandlerThread 类中的 run 方法

（2）run 方法内首先会获取当前线程的 id

（3）调用 Looper.prepate 方法创建 Looper 和 MessageQueue

（4）通过 synchronized 获取当前线程的 Looper 对象

• 拿到锁后会在内部通过 notifyAll 方法发出通知：当前线程已经创建 Looper 对象成功
• 此处使用锁机制 + notifyAll() 是为了保证后面获得 Looper 对象前就已经创建好了 Looper 对象

（5）调用 Process.setThreadPriority 方法设置当前线程的优先级

（6）调用 onLooperPrepared 方法在线程循环前做一些准备工作，这个方法需要在子类中重写出具体的实现

（7）最后调用 loop() 方法开启消息循环

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

步骤3 通过 HandlerThread 的 Looper 对象创建 Handler 对象，并重写 handleMessage 方法用于处理接收到的消息

获取 HandlerThread 的 Looper 时会调用 getLooper() 方法，这个方法内部会完成如下工作

（1）若线程不是存活的，则直接返回null

（2）若当前线程存活，则拿到 HandlerThread 对象的锁，其内会再判断线程的成员变量 mLooper 是否为 null

• 如果 mLooper 为 null，说明还未创建 Looper，则在循环内调用 wait 方法
• 这里会和之前的 notifyAll 方法形成一个生产者消费者机制，当 Looper 创建完毕后会 notifyAll，这样就会结束当前循环，继续执行

（3）最后返回拿到的 mLooper

步骤4 使用工作线程Handler向工作线程的消息队列发送消息

步骤5 quit 结束线程

这里就是 Handler 的机制了，可以参考上一章的陈述

2.IntentService

2.1 定义

Android 中的一个封装类，是继承自 Service 的抽象类，需要创建它的子类才能使用

2.2 作用

处理异步请求、实现多线程

2.3 使用场景

需要按顺序、在后台执行的、耗时的线程任务，任务执行后会自动停止

• 最常见的场景：离线下载

• 不符合多个数据同时请求的场景：所有的任务都在同一个 Thread Looper 里执行

2.4 使用步骤

（1）定义 IntentService 的子类，需重写 onHandleIntent() 方法

（2）在 Manifest.xml 中注册服务

（3）在 Activity 中开启 Service 服务

2.5 对比

与Service的区别

与其他线程的区别

2.6 源码分析

IntentService 本质 = Handler + HandlerThread：

（1）通过 HandlerThread 单独开启1个工作线程：IntentService

（2）创建1个内部 Handler：ServiceHandler

（3）绑定 ServiceHandler 与 IntentService

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

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

（4）通过 onStartCommand 方法传递服务 intent 到 ServiceHandler 、依次插入 Intent 到工作队列中并逐个发送给 onHandleIntent()

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

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

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);
    }
}

（5）通过 onHandleIntent 方法依次处理所有 Intent 对象所对应的任务

protected abstract void onHandleIntent(@Nullable Intent intent);

（6）如此循环直至没有传入新的 Intent

2.7 注意事项

工作任务队列 = 顺序执行

（1）若一个任务正在 IntentService 中执行，此时你再发送1个新的任务请求，这个新任务会一直等到前面一个任务执行完后才开始执行

（2）原因

• onCreate() 只会调用一次 = 只会创建1个工作线程

• 当多次调用 startService(Intent) 时，并不会创建新的工作线程，只是把消息加入消息队列中并等待执行

（3）若服务停止，则会清除消息队列中的消息，后续的事件不执行

不建议通过 bindService() 启动 IntentService

原因：

• 在 IntentService 中，onBind() 默认返回 null

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

次调用 startService(Intent) 时，并不会创建新的工作线程，只是把消息加入消息队列中并等待执行

（3）若服务停止，则会清除消息队列中的消息，后续的事件不执行

不建议通过 bindService() 启动 IntentService

原因：

• 在 IntentService 中，onBind() 默认返回 null

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

• 采用绑定方式启动的生命周期是 onCreate() ->> onBind() ->> onunbind()->> onDestory()，而不会调用 onStart() 或 onStartcommand()，自然不会将消息发送到消息队列，那么 onHandleIntent() 将不会回调，无法实现多线程的操作