当前位置：首页 > news >正文

Connor学Android - HandlerThread和IntentService

news 来源：原创 2024/5/4 15:16:08

在这里插入图片描述

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() 将不会回调，无法实现多线程的操作