本篇文章主要介绍以下几个知识点：

• 主线程和子线程
• Android 中的线程形态
• Android 中的线程池

hello，夏天 (图片来源于网络)

11.1 主线程和子线程

从用途上来说，线程分主线程和子线程。

主线程，指进程所拥有的线程，Android 中也叫 UI 线程，主要处理和界面相关的事情。

子线程，也叫工作线程（除主线程以外的线程都是子线程），往往用于执行耗时操作。

注：若在主线程中执行耗时操作会出现 ANR。

11.2 Android 中的线程形态

Android 中的线程形态除传统的 Thread 外，还包含 AsyncTask、HandlerThread、IntentService 等。

11.2.1 AsyncTask

AsyncTask 是一种轻量级的异步任务类，可在线程池中执行后台任务，把执行的进度和最终结果传给主线程并更新 UI。它封装了 Thread 和 Handler，但不适合进行特别耗时的后台任务（建议使用线程池）。

AsyncTask 是一个抽象的泛型类，如下：

// 三个泛型参数：
// 1. Params 参数的类型
// 2. Progress 后台任务的执行进度的类型
// 3. Result 后台任务的返回结果的类型
public abstract class AsyncTask<Params, Progress, Result>{ ... }

AsyncTask 提供了4个核心方法，典型示例如下：

/**
 * Function：模拟文件下载过程
 * 输入参数类型为URL，后台任务进程参数为Integer
 * 当要执行下载任务时：new DownloadFilesTask().execute(url1, url2, url3);
 */

public class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {

    /**
     * 核心方法 1：
     * 在主线程中执行，在异步任务执行之前调用，做一些准备工作
     */
    @Override
    protected void onPreExecute() {
        super.onPreExecute();
    }

    /**
     * 核心方法 2：
     * 在主线池中执行，用于执行异步任务，params 是异步任务的输入参数
     * 此方法中可用 publishProgress 来更新任务进度，它会调用 onProgressUpdate
     * 另外，此方法需要返回计算结果给 onPostExecute
     */
    @Override
    protected Long doInBackground(URL... params) {
        // 执行具体的下载任务并通过 publishProgress更新下载进度
        int count = params.length;
        long totalSize = 0;
        for (int i = 0; i < count; i++){
            totalSize += Downloader.downloadFile(params[i]);
            publishProgress((int)(i/(float)count) * 100);
            if (isCancelled())//判断是否被取消
                break;
        }
        // 返回下载的总字节数
        return totalSize;
    }

    /**
     * 核心方法 3：
     * 在主线程中执行，当后台任务的执行进度发生改变时调用
     */
    @Override
    protected void onProgressUpdate(Integer... values) {
        setProgressPercent(values[0]);
    }

    /**
     * 核心方法 4：
     * 在主线程中执行，在异步任务执行之后调用，result 是后台任务的返回值
     */
    @Override
    protected void onPostExecute(Long result) {
        showDialog("Download " + result + "bytes");
    }

    /**
     * 当异步任务被取消时调用
     */
    @Override
    protected void onCancelled() {
        super.onCancelled();
    }
}

AsyncTask 在具体使用过程中也有一些条件限制，如下：

1. AsyncTask 的类必须在主线程中加载，即第一次访问 AsyncTask 必须发生在主线程。

2. AsyncTask 的对象必须在主线程中创建。

3. execute 方法必须在 UI 线程调用。

4. 不要在程序中直接调用 AsyncTask 提供的4个核心方法。

5. 一个 AsyncTask 对象只能执行一次，即只能调用一次 execute 方法。

11.2.2 AsyncTask 的工作原理

源码分析。。。

11.2.3 HandlerThread

HandlerThread 继承了 Thread，是一种可使用 Handler 的 Thread，其实现核心在 run 方法中：

public void run(){
    mTid = Process.myTid();
    // 创建消息队列
    Looper.prepare();
    synchronized(this){
        mLooper = Looper.myLooper();
        notifyAll(); 
    }
    Process.setThreadPriority(mPriority);
    onLooperPrepared();
    // 开启消息循环
    Looper.loop();
    mTid = -1;
}

普通 Thread 主要用于在 run 方法中执行一个耗时任务，而 HandlerThread 在内部创建了消息队列，外界需要通过 Handler 的消息方式来通知 HandlerThread执行一个具体的任务。

HandlerThread 的 run 方法是一个无线循环，当不用 HandlerThread 时可通过其 quit 或 quitSafely 来终止线程的执行。

11.2.4 IntentService

IntentService 是一个继承了 Service 的抽象类，是一种特殊的 Service。

IntentService 可用于执行后台耗时任务，任务执行后它会自动停止，其优先级比单纯的线程要高，时候执行一些高优先级的后台任务。

IntentService 封装了 HandlerThread 和 Handler，这在其 onCreate 方法中可知：

    public void onCreate() {
        // TODO: It would be nice to have an option to hold a partial wakelock
        // during processing, and to have a static startService(Context, Intent)
        // method that would launch the service & hand off a wakelock.

        super.onCreate();
        // 1.创建一个 HandlerThread 
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        thread.start();

        mServiceLooper = thread.getLooper();
        // 2.构造一个 Handler 对象 mServiceHandler 
        // 这样通过 mServiceHandler 发送的消息最终都会在 HandlerThread 中执行
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }

每次启动 IntentService，它的 onStartCommand 方法就会调用一次，处理每个后台任务的 Intent，onStartCommand 调用了 onStart 方法如下：

public void onStart(Intent intent, int startId){
    Message msg = mServiceHandler.obtainMessage();
    msg.arg1 = startId;
    msg.obj = intent;
    // IntentService 通过 mServiceHandler 发送了一个消息
    // 这个消息会在 HandlerThread 中被处理
    mServiceHandler.sendMessage(msg);
}

其中 ServiceHandler 的实现如下：

private final class ServiceHandler extends Handler{
    public ServiceHandler(Looper looper){
        super(looper);
    }

    @Override
    public void handleMessage(Message msg){
        onHandleIntent((Intent)mag.obj);
        // 停止服务
        stopSelf(msg.arg1);
    }
}

IntentService 的 onHandleIntent 是一个抽象方法，其作用是从 intent 参数中区分具体的任务并执行这些任务。

11.3 Android 中的线程池

线程池的优点可概括为以下3点：

1. 重用线程池中的线程，避免因为线程的创建和销毁所带来的性能开销。

2. 能有效控制线程池的最大并发数，避免大量的线程之间因互相抢占系统资源而导致的阻塞现象。

3. 能够对线程进行简单的管理，并提供定时执行以及指定间隔循环执行等功能。

Android 中的线程池都是直接或间接通过配置 ThreadPoolExecutor 来实现的。

11.3.1 ThreadPoolExecutor

ThreadPoolExecutor 是线程池的真正实现，其构造方法提供了一系列参数来配置线程池如下：

// corePoolSize 线程池的核心线程，默认情况下会在线程池中一直存活
// maximumPoolSize 线程中所能容纳的最大线程数
// keepAliveTime 非核心线程闲置时的超时时长，超过这个时长非核心线程就会被回收
// unit 用于指定 keepAliveTime 参数的时间单位
// workQueue 线程池中的任务队列，通过线程池的 execute 方法提交的 Runnable 对象会存储在此参数中
// threadFactory 线程工厂，为线程池提供创建新线程的功能
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable>workQueue,
                          ThreadFactory threadFactory)

ThreadPoolExecutor 执行任务时大致遵循如下规则：

1. 若线程池中的线程数量未达到核心线程的数量，那么会直接启动一个核心线程来执行任务。

2. 若线程池中的线程数量已达到或超过核心线程的数量，那么任务会被插入到任务队列中等待执行。

3. 若在步骤 2 中无法将任务插入到任务队列中，此时若线程数量未达到线程池规定的最大值，则会立刻启动一个非核心线程来执行任务。

4. 若步骤 3 中线程数量已达到线程池规定的最大值，那么就拒绝执行任务，会调用 RejectedExecutionHandler 的 rejectExecution 来通知调用者。

ThreadPoolExecutor 的配置参数可在 AsyncTask 中体现，配置后的线程池规格如下：

• 核心线程数等于 CPU 核心数 + 1

• 线程池的最大线程数为 CPU 核心数的 2 倍 + 1

• 核心线程无超时机制，非核心线程子闲置时的超时时间为 1 秒

• 任务队列的容量为 128

11.3.2 线程池的分类

1. FixedThreadPool

通过 executors 的 newFixedThreadPool 方法来创建，是一种线程数量固定的线程池，当线程处于空闲时不会被回收（除非线程池被关闭了），其实现如下：

public static ExecutorService newFixedThreadPool(int nThreads){
    // FixedThreadPool 只有核心线程并且没用超时机制，任务队列也没有大小限制
    // 意味着它能够更加快速地响应外界的请求
    return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockQueue<Runnable>());
}

2. CachedThreadPool

通过 executors 的 newCachedThreadPool 方法来创建，是一种线程数量不定的线程池，只有非核心线程，且最大线程数为 Integer.MAX_VALUE，其实现如下：

public static ExecutorService newCachedThreadPool(){
    // 线程池中的空闲线程都有超时机制时长为60秒，超过60秒闲置线程就会被回收
    // CachedThreadPool 的任务队列相当于一个空集合，任何任务都会被立即执行
    // 这类线程池比较适合执行大量的耗时较少的任务
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.MILLISECONDS, new SynchronousQueue<Runnable>());
}

3. ScheduledThreadPool

通过 executors 的 newScheduledThreadPool 方法来创建，其核心线程数固定，非核心线程数无限制，其实现如下：

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize){
    // 这类线程池主要用于执行定时任务和具有固定周期的重复任务
    return new ScheduledThreadPoolExecutor(corePoolSize);
}

public ScheduledThreadPoolExecutor(int corePoolSize){
    super(corePoolSize, Integer.MAX_VALUE, 0, NANSECONDS, new DelayedWorkQueue());
}

4. SingleThreadExecutor

通过 executors 的 newSingleThreadExecutor 方法来创建，内部只有一个核心线程，确保所有的任务都在同一个线程中按顺序执行。其实现如下：

public static ExecutorService newSingleThreadExecutor(){
    // SingleThreadExecutor 的意义在于统一所有的外界任务到一个线程中，使得这些任务之间不需要处理线程同步的问题
    return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()));
}

以上便是 Android 中常见的 4 种线程池，实际开发也可根据需要灵活配置线程池。4 种线程池的使用方法如下：

Runnable command = new Runnable(){
    @Override
    public void run(){
        SystemClock.sleep(2000);
    }
};

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(4);
fixedThreadPool.execute(command);

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
cachedThreadPool .execute(command);

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(4);
// 2000ms 后执行 command
scheduledThreadPool .schedule(command, 2000, TimeUnit.MILLISECONDS);
// 延迟 10ms 后，每隔 1000ms 执行 一次command
scheduledThreadPool .scheduleAtFixedRate(command, 10, 1000, TimeUnit.MILLISECONDS); 

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
singleThreadExecutor .execute(command);

本篇文章就介绍到这。