java线程池复习

在操作系统中，线程是操作系统调度的最小单位，同时线程又是一种受限的系统资源，即线程不可能无限地产生，并且线程的创建和销毁都会有相应的开销。所以就有了线程池的引入，它可以避免因为频繁创建和销毁线程所带来的系统开销。Android中的线程来源于java，主要是通过java1.5之后的Executor来派生特定的线程池。

优点：
(1).重用线程池中的线程，避免因为线程的创建和销毁所带来的性能开销。
(2).能有效地控制线程池的最大并发数，避免大量的线程之间因互相抢占系统资源而导致的阻塞现象。
(3).能够对线程进行简单的管理，并提供定时执行以及指定间隔循环执行等功能。

Executor接口的真正实现为ThreadPoolExecutor，通过配置它的参数可以创建各种线程池。在介绍线程池的种类之前，先需要介绍下该类中每个参数的作用。

ThreadPoolExecutor

它有四个构造函数提供我们实例化，最多的构造方法有七个

//七个参数的构造函数
public ThreadPoolExecutor(int corePoolSize,
                     int maximumPoolSize,
                     long keepAliveTime,
                     TimeUnit unit,
                     BlockingQueue<Runnable> workQueue,
                     ThreadFactory threadFactory,
                     RejectedExecutionHandler handler)

1.核心线程 corePoolSize

线程池新建线程时，如果当前线程总数小于核心线程 corePoolSize，则新建核心线程，如果超过corePoolSize，则新建非核心线程。

核心线程默认是一直在存活在线程池中，即使处于闲置状态。

如果指定 ThreadPoolExecutor 的 allowCoreThreadTimeOut 这个属性为 true，那么核心线程如果处于闲置状态的话，超过一定时间(keepAliveTime)，就会被销毁掉。

2.线程总数 maximumPoolSize

线程中的最大线程数，等于核心线程加上非核心线程。

3.超时时间 keepAliveTime

非核心线程超时时长，一个非核心线程的闲置时间超过这个线程设置的时长，就会被销毁。同时如果设置allowCoreThreadTimeOut = true，则也会作用于核心线程。

4 . 时间单位

keepAliveTime 的时间单位 TimeUnit ，枚举值，有以下几种：

NANOSECONDS ： 1微毫秒 = 1微秒 / 1000
MILLISECONDS ： 1毫秒 = 1秒 /1000
SECONDS ：秒
MINUTES ：分
HOURS ：小时
DAYS ：天

5 . 队列 BlockingQueue

它是一个接口，代表一个任务队列，也可以说是一个阻塞队列，维护着等待执行的runnable, 当所有的核心线程创建之后，就会将待执行的任务存入任务队列，如果任务队列满了，则创建非核心线程，根据具体的实现，有不同的使用情形，下面是常用的任务队列实现。

SynchronousQueue 任务队列接受任务时，把任务直接提交给线程处理，如果所有线程都在工作，那就新创建一个线程来处理，所以此种任务队列一般需要设置maximumPoolSize为 Integer.MAX_VALUE，以防出现不能新建线程产生错误。

LinkedBlockingQueue 任务队列接受任务时候，如果当前线程数小于核心线程数，则新建核心线程处理任务，如果当前线程数等于核心线程数，则进入队列等待，由于这个任务队列没有最大值限制，则所有超过核心线程都会被添加到队列中，这也就导致了maximumPoolSize 的设定失效，线程总数不会超过corePoolSize

ArrayBlockingQueue 限定任务队列的长度，接受到任务时候，如果没有达到corePoolSize 的值，则新建核心线程执行任务，如果已经达到了，则入队列等待，如果队列已经满了，则新建非核心线程执行任务，如果线程总数达到了maximumPoolSize，则发生错误

DelayQueue 队列内元素必须实现Delayed 接口，这就表示你传进去的任务必须实现Delayed 接口，入队列的元素，首先会先入队列，只有达到了指定的延时时间，才会执行任务

6 . ThreadFactory

创建线程的方式，Executors 有默认的ThreadFactory创建方式，一般没有特别需求可以直接使用它的默认实现方式，调用者不需要做操作，提交的任务通过它创建线程

/**
     * The default thread factory.
     */
    private static class DefaultThreadFactory implements ThreadFactory {
...
        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r,
                                  namePrefix + threadNumber.getAndIncrement(),
                                  0);
            if (t.isDaemon())
                t.setDaemon(false);
            if (t.getPriority() != Thread.NORM_PRIORITY)
                t.setPriority(Thread.NORM_PRIORITY);
            return t;
        }
    }

7 . RejectedExecutionHandler

抛出异常专用，也就是线程池的饱和策略，ThreadPoolExecutor 实现了几种常用异常

ThreadPoolExecutor.AbortPolicy:默认的策略，丢弃任务并抛出RejectedExecutionException异常，这种策略需要加try catch，否则程序会直接退出
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常，空方法。
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）。
ThreadPoolExecutor.CallerRunsPolicy 在调用execute的线程里面执行此策略，会阻塞入口
用户自定义饱和策略（最常用）
实现RejectedExecutionHandler，并自己定义策略模式

这里借鉴下这个大神的图

这里写图片描述

该图展示了ThreadPoolExecutor 下线程池的执行流程，关于线程池详细源码分析以及使用过程，可以看这篇文章

线程执行处理流程步骤：
(1).提交任务后，线程池先判断线程数是否达到了核心线程总数，如果未达到核心线程总数，则创建核心线程数；否则执行下一步骤
(2).接着线程池判断任务队列是否满了。如果没满，则将任务添加到任务队列中；否者，则执行下一步操作。
(3).接着因为任务队列满了，线程池就判断线程数是否达到了最大线程数。如果未达到，则创建非核心线程处理任务。否则执行饱和策略，默认抛出RejectedExecutionHandler异常

常见的四种线程池

Executors默认给我们提供了几种线程池，常用的有四种，都是通过ThreadPoolExecutor 直接或者间接实现的，调用者可以很方便的使用它

1 . CachedThreadPool

创建方法：

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

借助下Android进阶之光的图来看下它的执行流程
这里写图片描述

这个线程池没有核心线程，线程总数为Integer.MAX_VALUE，线程存活时间为60s，用到了阻塞队列SynchronousQueue ，是一个不存储元素的队列，一个元素的插入必须等另一个元素的移除操作。当执行execute 方法首先执行SynchronousQueue的offer方法提交任务，然后查询线程池是否有空闲线程，执行任务，有就将任务交给空闲线程执行任务，没有就新创建非核心线程，然后调用poll来移除任务，交给线程处理任务。当线程空闲时候，就会调用poll 等待任务的提交，如果60s空闲线程没有处理任务就会被终止。

好处：

1.线程无限制
2.有空闲线程则复用空闲线程，若无空闲线程则新建线程
3.一定程序减少频繁创建/销毁线程，减少系统开销
4.适合执行大量的耗时较少的任务

2 .FixedThreadPool

创建方法：

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

这里写图片描述

只有核心线程，线程总数是一定的，采用了无界的阻塞队列LinkedBlockingQueue，当执行execute方法时候，如果当前线程总数没有超过核心线程总数，就会创建核心线程，否则就会将任务提交给队列，当核心线程有空闲的时候，就回去任务队列中取任务执行。

好处：

1.可控制线程最大并发数（同时执行的线程数）
2.超出的线程会在队列中等待
3.由于都是核心线程，能够更快的响应外界请求

3 . ScheduledThreadPool

创建方法：

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}

public ScheduledThreadPoolExecutor(int corePoolSize,
                                   ThreadFactory threadFactory) {
    super(corePoolSize, Integer.MAX_VALUE,
          DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
          new DelayedWorkQueue(), threadFactory);
}

这里写图片描述

执行ScheduledThreadPoolExecutor的scheduleAtFixedRate或者scheduledWithFixedDelay方法时候，会向DelayWorkQueue添加一个实现RunableScheduledFuture接口的ScheduledFutureTask任务包装类，并会检查运行的线程是否达到了核心线程，如果没有则新建线程启动它，单不会立即执行，而是去DelayWorkQueue中取ScheduledFutureTask然后执行异步任务。如果达到核心线程，则将任务添加到DelayWorkQueue，它会将任务进行排序，并会将ScheduledFutureTask的time变量改为下次要执行的时间并放回DelayWorkQueue中

好处：

1 . 这个线程池支持定时或者具有固定周期的重复性任务

4 . SingleThreadExecutor

创建方法：

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

这里写图片描述

只有一个核心线程，其它流程和FixedThreadPool 一样。

好处：

1.有且仅有一个工作线程执行任务
2.所有任务按照指定顺序执行，即遵循队列的入队出队规则

关于这几种线程池的原理，可以看这篇文章

Android中线程池的使用

作为一名Android开发者，在平时我们开发中，使用的原生API或者第三方库，都会或多或少使用线程池，下面举出几个我在平时开发中使用到线程池的地方。

1 . EventBus中线程池的使用

熟悉EventBus源码的人都会知道，它里面有三个Poster，不熟悉的看这里，它在EventBus中起到一个线程切换的作用，同时也提供一个线程去执行异步任务。其中它们的默认使用如下

private final static ExecutorService DEFAULT_EXECUTOR_SERVICE = Executors.newCachedThreadPool();

可以看见创建了一个CachedThreadPool，这个线程池都是非核心线程，可以在一定程度上减轻频繁创建线程所带来的线程开销。

关于它的源码可以看张拭心的EventBus文章

2 . Okhttp中线程池的使用

在Okhttp中有个分发器Dispatcher，在里面维护了一个executorService，它的创建如下：

public synchronized ExecutorService executorService() {
 if (executorService == null) {
   executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS,
       new SynchronousQueue<Runnable>(), Util.threadFactory("OkHttp Dispatcher", false));
 }
 return executorService;
}

它是完全自定义的ThreadPoolExecutor，可以看见它的核心线程为0，非核心线程设置为
Integer.MAX_VALUE 和和EventBus的线程数一样

关于它的源码可以看张拭心的okhttp这篇文章，挺详细的

3 . AsyncTask中线程池的使用

刚学Android的时候，这个AsyncTask 作为异步任务的API 用得还是比较广的，它里面封装了线程池和Handler，在异步任务和UI线程中切换非常方便，看下其线程池的使用

private static final ThreadFactory sThreadFactory = new ThreadFactory() {
        private final AtomicInteger mCount = new AtomicInteger(1);

        public Thread newThread(Runnable r) {
            return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
        }
    };

static {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
                sPoolWorkQueue, sThreadFactory);
    }

它的核心线程是Math.max(2, Math.min(CPU_COUNT - 1, 4))， CPU_COUNT 是CPU的数，也就是CPU核心数+1，总线程总数是CPU_COUNT * 2 + 1，而它的任务队列是new LinkedBlockingQueue<Runnable>(128)，这样它的任务队列的最大长度是128。这样就达到了控制线程的并发数，当线程达到最大核心线程数时候，其它任务就会被放到任务队列中。

还有很多地方也用到了线程池，就不一一举例了。

关于它的源码可以看Android开发者进阶，或者Android开发者艺术探索，都有它的源码讲解

参考文档

1 . 详解 Java 线程池
2 . Android开发者探索
3 . Android开发者进阶
4 . Java线程池(ThreadPoolExecutor)原理分析与使用
5 . Java线程Executor框架详解与使用

ThreadPoolExecutor

常见的四种线程池

Android中线程池的使用

参考文档

猜你喜欢