Android 线程池

使用线程池的优点

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

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

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

 

线程池参数

CorePoolSize 

线程的核心线程数。
默认情况下，核心线程数会在线程中一直存活，即使它们处于闲置状态。

如果将ThreadPoolExecutor的allowCoreThreadTimeOut属性设置为true，那么核心线程就会存在超时策略，这个时间间隔有keepAliveTime所决定，当等待时间超过keepAliveTime所指定的时长后，核心线程就会被停止。

maximumPoolSize 
线程池所能容纳的最大线程数。

当活动线程数达到这个数值后，后续的新任务将会被阻塞。

keepAliveTime 

非核心线程闲置时的超时时长，超过这个时长，非核心线程就会被回收，当ThreadPoolExector的allowCoreThreadTimeOut属性设置为True时，keepAliveTime同样会作用于核心线程。

unit 

用于指定keepAliveTime参数的时间单位，这是一个枚举，常用的有TimeUnit.MILLISECONDS（毫秒）、TimeUnit.SECONDS(秒)以及TimeUnit.MINUTES(分钟)等。

workQueue 
线程池中的任务队列，通过线程池execute方法提交的Runnable对象会存储在这个参数中。

这个任务队列是BlockQueue类型，属于阻塞队列，就是当队列为空的时候，此时取出任务的操作会被阻塞，等待任务加入队列中不为空的时候，才能进行取出操作，而在满队列的时候，添加操作同样被阻塞。

线程池的4种分类及特点

FixedThreadPool

//核心线程数和最大线程数相同.
//无超时时间
    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(
                nThreads, nThreads,
                0L, TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>()

        );

这是一种数量固定的线程池,当线程处于空闲的时候,并不会被回收,除非线程池被关闭.
当所有的线程都处于活动状态时,新任务都会处于等待状态,直到有线程空闲出来.
由于FixedThreadPool中只有核心线程并且这些核心线程不会被回收,这意味着它能够更加快速地响应外界的请求.

通过构造方法可以看出,FixedThreadPool只有核心线程,并且超时时间为0(即无超时时间),所以不会被回收.

（1）从配置参数来看，FixThreadPool只有核心线程，并且数量固定的，也不会被回收，所有线程都活动时，因为队列没有限制大小，新任务会等待执行。
（2）FixThreadPool其实就像一堆人排队上公厕一样，可以无数多人排队，但是厕所位置就那么多，而且没人上时，厕所也不会被拆迁。
（3）由于线程不会回收，FixThreadPool会更快地响应外界请求，这也很容易理解，就好像有人突然想上厕所，公厕不是现用现建的。

CacheThreadPool

//无核心线程,并且最大线程数为int的最大值.
//超时时间为60s

//队列为SynchronousQueue同步阻塞队列,队列中没有任何容量.只有在有需求的情况下,队列中才可以试着添加任务.

public static  ExecutorService newCacheThreadPool(){

        return  new ThreadPoolExecutor(
                0,Integer.MAX_VALUE,
                60L,TimeUnit.SECONDS,
                new SynchronousQueue<Runnable>()
        );

    }

它是一种线程数量不定的线程池,它只有非核心线程,并且其最大线程数为Integer.MAX_VALUE(也就相当于线程池的线程数量可以无限大).
当线程池中所有线程都处于活动的状态时,线程池会创建新的线程来处理新任务,否则就会复用空闲线程来处理.
值得注意的是,这个线程池中储存任务的队列是SynchronousQueue队列,这个队列可以理解为无法储存的队列,只有在可以取出的情况下,才会向其内添加任务.
从整个CacheThreadPool的特性来看:
(1)比较适合执行大量的耗时较少的任务.

(2)当整个线程都处于闲置状态时,线程池中的线程都会超时而被停止,这时候的CacheThreadPool几乎不占任何系统资源的.（3）CachedThreadPool只有非核心线程，最大线程数非常大，所有线程都活动时，会为新任务创建新线程，否则利用空闲线程（60s空闲时间，过了就会被回收，所以线程池中有0个线程的可能）处理任务。

（4）任务队列SynchronousQueue相当于一个空集合，导致任何任务都会被立即执行。

（5）【前方高能，笔者脑洞】CachedThreadPool就像是一堆人去一个很大的咖啡馆喝咖啡，里面服务员也很多，随时去，随时都可以喝到咖啡。但是为了响应国家的“光盘行动”，一个人喝剩下的咖啡会被保留60秒，供新来的客人使用，哈哈哈哈哈，好恶心啊。如果你运气好，没有剩下的咖啡，你会得到一杯新咖啡。但是以前客人剩下的咖啡超过60秒，就变质了，会被服务员回收掉。

（6）比较适合执行大量的耗时较少的任务。喝咖啡人挺多的，喝的时间也不长。

ScheduledThreadPool  （4个里面唯一一个有延迟执行和周期重复执行的线程池）

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSzie) {
        return new ScheduledThreadPoolExecutor(corePoolSzie);
    }
//核心线程数是固定的,非核心线程无限大,并且非核心线程数有10s的空闲存活时间
public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE,
                DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
                new DelayedWorkQueue());

    }

它的核心线程数量是固定的,而非核心线程数是没有限制的,并且当非核心线程闲置时会被立即回收.
ScheduThreadPool这类线程池主要用于执行定时任务和具有固定周期的重复任务.

而DelayedWorkQueue这个队列就是包装过的DelayedQueue,这个类的特点是在存入时会有一个Delay对象一起存入,代表需要过多少时间才能取出,相当于一个延时队列.

（1）核心线程数固定，非核心线程（闲着没活干会被立即回收）数没有限制。

（2）从上面代码也可以看出，ScheduledThreadPool主要用于执行定时任务以及有固定周期的重复任务。

SingleThreadExecutor

public static ExecutorService newSingleThreadExecutor() {
        return Executors.newSingleThreadExecutor();
    }
    //线程中只有一个核心线程
    //并且无超时时间
    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
                (new ThreadPoolExecutor(1, 1,
                        0L, TimeUnit.MILLISECONDS,
                        new LinkedBlockingQueue<Runnable>()));

    }

这类线程池内部只有一个核心线程,它确保所有的任务都在同一个线程中按顺序执行.
SingleThreadExecutor的意义在于统一外界所有任务到一个线程,这使得这些任务之间不需要处理线程同步的问题.

2 提交任务

可以使用execute和submit两个方法向线程池提交任务

（1）execute方法用于提交不需要返回值的任务，利用这种方式提交的任务无法得知是否正常执行

1. threadPoolExecutor.execute(new Runnable() {

2.  

3. @Override

4. public void run() {

5. try {

6. Thread.sleep(5000);

7. } catch (InterruptedException e) {

8. e.printStackTrace();

9. }

10. }

11. });

（2） submit方法用于提交一个任务并带有返回值，这个方法将返回一个Future类型对象。可以通过这个返回对象判断任务是否执行成功，并且可以通过future.get()方法来获取返回值，get()方法会阻塞当前线程直到任务完成。

3 关闭线程池

可以通过调用线程池的shutdown或shutdownNow方法来关闭线程池。他们的原理是遍历线程池中的工作线程，然后逐个调用线程的interrupt方法来中断线程，所以无响应中断的任务可能永远无法停止。但是他们存在一定的区别，shutdownNow首先将线程池的状态设置为STOP，然后尝试停止所有正在执行或暂停任务的线程，并返回等待执行任务的列表，而shutdown只是将线程池的状态设置成SHUTDOWN状态，然后中断所有正在执行的任务。

只要调用了这两个关闭方法的一个，isShutdown就会返回true。当所有的任务都关闭后，才表示线程池关闭成功，这是调用isTerminated方法会返回true。至于应该调用哪一种方法来关闭线程池，应该由提交到线程池的任务特性决定，通常调用shutdown方法来关闭线程池，如果任务不一定执行完，则可以调用shutdownNow方法。

分别测试shutdown和shutdownNow()方法，结果shutdown()方法的调用并不会引发中断，而shutdownNow()方法则会引发中断。这也正验证前面所说的，shutdown方法只是发出了停止信号，等所有线程执行完毕会关闭线程池；而shutdownNow则是立即停止所有任务。

4 合理配置线程池

要想合理地配置线程池，首先要分析任务特性

• 任务的性质：CPU密集型任务、IO密集型任务和混合型任务。
• 任务的优先级：高、中和低。
• 任务的执行时间：长、中和短。
• 任务的依赖性：是否依赖其他系统资源，如数据库连接。

性质不同的任务可以用不同规模的线程池分开处理。CPU密集型任务应该配置尽可能少的线程，如配置N+1个线程，N位CPU的个数。而IO密集型任务线程并不是一直在执行任务，则应配置尽可能多的线程，如2*N。混合型任务，如果可以拆分，将其拆分成一个CPU密集型任务和一个IO密集型任务，只要这两个任务执行的时间相差不是太大，那么分解后执行的吞吐量将高于串行执行的吞吐量

优先级不同的任务可以交给优先级队列PriorityBlcokingQueue来处理。

执行时间不同的任务可以交给不同规模的线程池来处理。

依赖数据库的任务，因此线程提交SQL后需要等待数据库返回结果，等待的时间越长，则CPU空闲时间越长，那么线程数应该设置的越大，这样能更好滴利用CPU。

线程池的拒绝策略

jdk自带的四种策略

（1）ThreadPoolExecutor.AbortPolicy 丢弃任务，并抛出 RejectedExecutionException 异常。

（2）ThreadPoolExecutor.CallerRunsPolicy：该任务被线程池拒绝，由调用 execute方法的线程执行该任务。

（3）ThreadPoolExecutor.DiscardOldestPolicy ： 抛弃队列最前面的任务，然后重新尝试执行任务。

（4）ThreadPoolExecutor.DiscardPolicy，丢弃任务，不过也不抛出异常。

当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize，如果还有任务到来就会采取任务拒绝策略。

4、ThreadPoolExecutor处理任务的顺序、原理

一个任务通过 execute(Runnable) 方法被添加到线程池，任务就是一个 Runnable 类型的对象，任务的执行方法就是 Runnable 类型对象的 run() 方法。

当一个任务通过 execute(Runnable) 方法欲添加到线程池时，线程池采用的策略如下（即添加任务的策略）：

如果此时线程池中的数量小于 corePoolSize ，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。

如果此时线程池中的数量等于 corePoolSize ，但是缓冲队列 workQueue 未满，那么任务被放入缓冲队列。

如果此时线程池中的数量大于 corePoolSize ，缓冲队列 workQueue 满，并且线程池中的数量小于maximumPoolSize ，建新的线程来处理被添加的任务。

如果此时线程池中的数量大于 corePoolSize ，缓冲队列 workQueue 满，并且线程池中的数量等于maximumPoolSize ，那么通过 handler 所指定的策略来处理此任务。

任务处理的优先级（顺序）为：

核心线程 corePoolSize 、任务队列 workQueue 、最大线程 maximumPoolSize ，如果三者都满了，使用 handler处理被拒绝的任务。当线程池中的线程数量大于 corePoolSize 时，如果某线程空闲时间超过 keepAliveTime ，线程将被终止。这样，线程池可以动态的调整池中的线程数。
有界队列，无界队列

常见的有界队列为

ArrayBlockingQueue 基于数组实现的阻塞队列

LinkedBlockingQueue 其实也是有界队列，但是不设置大小时就是无界的。

ArrayBlockingQueue 与 LinkedBlockingQueue 对比一哈

ArrayBlockingQueue 实现简单，表现稳定，添加和删除使用同一个锁，通常性能不如后者

LinkedBlockingQueue 添加和删除两把锁是分开的，所以竞争会小一些

SynchronousQueue 比较奇葩，内部容量为零，适用于元素数量少的场景，尤其特别适合做交换数据用，内部使用 队列来实现公平性的调度，使用栈来实现非公平的调度，在Java6时替换了原来的锁逻辑，使用CAS代替了

上面三个队列他们也是存在共性的

put take 操作都是阻塞的

offer poll 操作不是阻塞的，offer 队列满了会返回false不会阻塞，poll 队列为空时会返回null不会阻塞

补充一点，并不是在所有场景下，非阻塞都是好的，阻塞代表着不占用CPU，在有些场景也是需要阻塞的，put take 存在必有其存在的必然性

常见的无界队列

ConcurrentLinkedQueue 无锁队列，底层使用CAS操作，通常具有较高吞吐量，但是具有读性能的不确定性，弱一致性——不存在如ArrayList等集合类的并发修改异常，通俗的说就是遍历时修改不会抛异常

PriorityBlockingQueue 具有优先级的阻塞队列

DelayedQueue 延时队列，使用场景

缓存：清掉缓存中超时的缓存数据

任务超时处理

补充：内部实现其实是采用带时间的优先队列，可重入锁，优化阻塞通知的线程元素leader

LinkedTransferQueue 简单的说也是进行线程间数据交换的利器，在SynchronousQueue 中就有所体现，并且并发大神 Doug Lea 对其进行了极致的优化，使用15个对象填充，加上本身4字节，总共64字节就可以避免缓存行中的伪共享问题，其实现细节较为复杂，可以说一下大致过程：

比如消费者线程从一个队列中取元素，发现队列为空，他就生成一个空元素放入队列 , 所谓空元素就是数据项字段为空。然后消费者线程在这个字段上旅转等待。这叫保留。直到一个生产者线程意欲向队例中放入一个元素，这里他发现最前面的元素的数据项字段为 NULL，他就直接把自已数据填充到这个元素中，即完成了元素的传送。大体是这个意思，这种方式优美了完成了线程之间的高效协作

线程池的终止

Future有，那我们可以结合Future，提供一种自动停止超时任务的方式，来解决某个任务Hang住的问题。

我们简单修改下，把sleep逻辑移动到Callable中，并在Runner中使用Future来控制超时。

public class pool {
    private static class Caller implements Callable<Boolean> {
        @Override
        public Boolean call() {
            try {
                Thread.sleep(10000);
                System.out.println(new Date());
                return true;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return false;
        }
    }

    private static class Runner implements Runnable {
        @Override
        public void run() {
            ExecutorService excutor = Executors.newSingleThreadExecutor();
            Future<Boolean> future = excutor.submit(new Caller());
            try {
                future.get(1, TimeUnit.SECONDS);
            } catch (TimeoutException e) {
                System.out.println("timeout");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                excutor.shutdownNow(); // 强制终止任务
            }
        }
    }

    public static void main(String[] args) {
        ScheduledExecutorService service
                = Executors.newScheduledThreadPool(1);
        service.scheduleAtFixedRate(
                new Runner(), 0, 1, TimeUnit.SECONDS);
    }
}