四种线程池详细解析

为什么会有线程池？？

　　之前的时候，我们每使用一次线程就去创建一个线程，这样虽然实现起来非常简便，但是会有一个问题，如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间，而且还容易造成线程池溢出。于是人们想到了使用线程池的方法，这样使得线程就可以被复用，就是说当一个线程执行完一个任务后，并不会被销毁，而是放到线程池中，这样再次需要使用线程时，就可以直接从线程池中拿取一个线程使用，从而降低资源消耗，提高利用效率。

• 线程的创建和销毁是需要时间的。加入一个服务完成需要的时间：T1表示创建线程时间，T2表示线程执行任务的耗时，T3表示线程消耗的时间，如果：T1+T3远大于T2，得不偿失。
• 线程需要占用内存资源，大量线程的创建会占用宝贵内存资源，可以导致OOM（Out Of Memory）异常。
• 大量的线程回收时也会给GC操作带来很大的压力，延长GC的停顿时间。
• 线程抢占CPU资源，CPU不停的在各个线程中进行上下文切换，上下文的切换也是耗时的过程。

线程池溢出：频繁创建多线程，非常占用CPU内存，一个线程占1MB内存。

线程池的目的：

　　1.通过重复利用线程池中已创建的代码，来降低创建和销毁线程时的开销，从而降低资源消耗，提高利用效率。

　　2.提高响应速度。当任务到达时，任务不需要来等待线程创建就能立即执行，因为线程池中有已创建好的线程可以直接供使用。

　　3.提高线程的可管理性。线程池时稀缺资源，如果无限制的创建，当线程数到达一定数量时，不仅会消耗系统资源，还会降低系统的稳定性，所以使用线程池，就可以进行统一分配，调优和监控。

　　4. 提供定时执行、定期执行、单线程、并发数控制等功能。

 线程池的继承：

　　Java里面线程池的顶级接口是Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是ExecutorService，ExecutorService接口继承了Excutor接口，提供了一些对线程池操作的扩展方法：shoudown,submit，是真正的线程池接口。Executors是线程池的静态工厂，其提供了快捷创建线程池的静态方法。AbstractExecutorService抽象类实现了ExecutorService接口提供的大部分方法

比较重要的几个类：

ExecutorService接口	真正的线程池接口。
ScheduledExecutorService接口	能和Timer/TimerTask类似，解决那些需要任务重复执行的问题。
ThreadPoolExecutor类	ExecutorService的默认实现。
ScheduledThreadPoolExecutor类	继承ThreadPoolExecutor和实现ScheduledExecutorService接口，周期性任务调度的类实现。

 

Executors慎用：
在《阿里巴巴Java开发手册》中有一条
【强制】线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。
Executors 返回的线程池对象的弊端如下:
FixedThreadPool 和 SingleThreadPool : 允许的请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。
CachedThreadPool 和 ScheduledThreadPool : 允许的创建线程数量为 Integer.MAX_VALUE，可能会创建大量的线程，从而导致 OOM。

要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在Executors类里面提供了一些静态工厂，生成一些常用的线程池。

线程池的四种创建方式：

Java通过Executors(java1.5并发包中的类)来创建四种线程池，分别为：

newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则创建线程。

newFixedThreadPool创建一个定长线程池，可控制线程池最大并发数，超出的线程会在队列中等待。

newScheduledThreadPool创建一个 定时线程池，支持定时以及周期性任务执行。

newSingleThreadExecutor创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序执行。（FIFO,LIFO,优先级）

无论创建哪种线程池在其底层都 必须要调用ThreadPoolExecutor：

•  corePoolSize： 核心线程数---线程池中实际运行的线程数
•  maximumPoolSize：最大线程数---线程池创建线程的最大数量 。值得注意的是，如果使用了无界的任务队列这个参数就没什么效果。
•  keepAliveTime： 线程池维护线程所允许的空闲时间 
•  unit： 线程池维护线程所允许的空闲时间的单位 。可选的单位有天（DAYS）、小时（HOURS）、分钟（MINUTES）、毫秒（MILLISECONDS）、微秒（MICROSECONDS，千分之一毫秒）和纳秒（NANOSECONDS，千分之一微秒）。
•  workQueue： 线程池所使用的缓冲队列 
•  handler： 线程池对拒绝任务的处理策略。当队列和线程池都满了，说明线程池处于饱和状态，那么必须采取一种策略处理提交的新任务。这个策略默认情况下是AbortPolicy，表示无法处理新任务时抛出异常。在JDK 1.5中Java线程池框架提供了以下4种策略。
  ·AbortPolicy：直接抛出异常。
  ·CallerRunsPolicy：只用调用者所在线程来运行任务。
  ·DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务。
  ·DiscardPolicy：不处理，丢弃掉

 

线程池原理：

提交一个任务到线程池中，线程池的处理流程如下：

1.判断线程池里的核心线程数是否都在执行任务，如果不是（核心线程空闲或者还有核心线程没有被创建），则创建一个新的工作线程来执行任务。如果核心线程数都在执行任务，则进入下一个流程。

2.线程池判断工作队列是否已满，如果工作队列没有满，则将新提交的任务存储在这个工作队列里。如果工作队列满了，则进入下一个流程。

3.判断线程池里的线程是否都处于工作状态，如果没有，则创建一个新的工作流程来执行任务。如果已经满了，则交给饱和策略来处理这个任务。

 

 　　如果当前线程池中的线程数目小于corePoolSize，则每来一个任务，就会创建一个线程去执行这个任务；如果当前线程池中的线程数目大于等于corePoolSize，则每来一个任务，就会尝试将其添加到任务缓存队列当中，若添加成功，则该任务会等待空闲线程将其取出去执行；若添加失败（一般情况是因为任务缓存队列已满），则会尝试创建新的线程去执行这个任务，如果此时线程池中总线程数小于maximumPoolSize，则会创建新的线程，如果当前线程池中的线程数目大于等于maximumPoolSize，则会采取任务拒绝策略进行处理。

 　　注意：线程数目统计的是正在在执行任务的线程，而execute提交的只是任务，不一定每次提交都会创建出线程来。

1：newCachedThreadPool创建一个可缓存线程池。

　　♦CachedThreadPool的corePoolSize被设置为0，即corePool为空；

　　♦maximumPoolSize被设置为Integer.MAX_VALUE，即maximum是无界的。

　　♦这里keepAliveTime设置为60秒，意味着空闲的线程最多可以等待任务60秒，否则将被回收。

　　♦CachedThreadPool使用没有容量的SynchronousQueue作为主线程池的工作队列，它是一个没有容量的阻塞队列。每个插入操作必须等待另一个线程的对应移除操作。这意味着，如果主线程提交任务的速度高于线程池中处理任务的速度时，CachedThreadPool会不断创建新线程。极端情况下，CachedThreadPool会因为创建过多线程而耗尽CPU资源。

执行过程如下：

　　1.首先执行SynchronousQueue.offer(Runnable task)。如果在当前的线程池中有空闲的线程正在执行SynchronousQueue.poll()，那么主线程执行的offer()插入操作与空闲线程执行的poll()弹出操作配对成功，主线程把任务交给空闲线程执行，则execute()方法执行成功，否则执行步骤2

　　2.当线程池为空(初始maximumPool为空)或没有空闲线程时，将没有线程执行SynchronousQueue.poll操作，则配对失败。这种情况下，线程池会创建一个新的线程执行任务。

　　3.在创建完新的线程以后，将会执行poll操作，与执行SynchronousQueue.offer(Runnable task)的任务相匹配。当步骤2的线程执行完成后，将等待60秒，如果此时主线程提交了一个新任务，那么这个空闲线程将执行新任务，否则被回收。因此长时间不提交任务的CachedThreadPool不会占用系统资源。

　　SynchronousQueue是一个不存储元素阻塞队列，每次要进行offer插入操作时必须等待poll弹出操作，否则不能继续添加元素。

　　【代码演示】：耗时短，不需要考虑同步的情况。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CachedThreadDemo {
    public static void main(String[] args) {
        ExecutorService cachedthreadpool=Executors.newCachedThreadPool();
        for (int i = 0; i <10; i++) {
            cachedthreadpool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }
        cachedthreadpool.shutdown();
    }
}

运行结果：

2：newFixedThreadPool创建一个定长线程池。（指定core和max,且core=max=nThraed）

      

　　通过构造函数可知，该线程池的核心线程数和最大线程数是一样的。

• FixedThreadPool的corePoolSize的值和maxiumPoolSize的值都被设置为创建FixedThreadPool时指定的参数nThreads的大小。
• 0L则表示当线程池中的线程数量超过核心线程的数量时，多余的线程将被立即停止
• 最后一个参数表示FixedThreadPool使用了无界队列LinkedBlockingQueue作为线程池的做工队列，由于是无界的，当线程池的线程数达到corePoolSize后，新任务将在无界队列中等待，因此线程池的线程数量不会超过maxiumPoolSize，同时maxiumPoolSize也就变成了一个无效的参数，并且运行中的线程池也并不会拒绝任务。

执行过程如下：

　　1.如果当前工作中的线程数量少于corePool的数量，就创建新的线程来执行任务。

　　2.当线程池的工作中的线程数量达到了corePool，则将任务加入LinkedBlockingQueue。

　　3.线程执行完1中的任务后会从队列中去取任务。

注意LinkedBlockingQueue是无界队列，所以可以一直添加新任务到线程池。

　　【代码演示】：newFixedThreadPool创建一个定长线程池，可控制线程池最大并发数，超出的线程会在队列中等待。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class FixedThreadDemo {
    public static void main(String[] args) {
        ExecutorService  fixedThreadpool= Executors.newFixedThreadPool(3);//参数是线程池中线程的数目
        for (int i = 0; i <10 ; i++) {
            int tmp=i;
            fixedThreadpool.execute(new Runnable() {
            //execute方法表示启动线程
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+", "+tmp);
                }
            });
        }
        fixedThreadpool.shutdown();//停止线程池的运行
    }
}

运行结果：

 

 　　不论运行多少次，我们都可以看到，整个结果中其实只有3个线程，而且被反复利用着。

3：newScheduledThreadPool创建一个周期性的线程池。（指定core，max为max）

       

执行过程如下：

　　1.如果当前工作中的线程数量少于corePool的数量，就创建一个新的线程来执行任务。

　　2.当线程池的工作中的线程数量达到了corePool，则将任务加入DelayedWorkQueue。

　　3.线程执行完1中的任务后会从队列中去任务。

注意该线程池的最大线程数为MAX_VALUE。

　　【代码演示】：创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ScheduledThreadDemo {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledThreadpool=Executors.newScheduledThreadPool(2);//核心线程数
        //注意返回的是ScheduledExecutorService 类型的
        for (int i = 0; i <4; i++) {
            int tmp=i;
            /*scheduledThreadpool.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+", "+tmp);
                }
            }, 2, TimeUnit.SECONDS);
            //传进一个线程，2表示线程开始时的延时*/
            scheduledThreadpool.scheduleAtFixedRate(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+", "+tmp);
                }
            }, 2,3, TimeUnit.SECONDS);
            //传进一个线程，2表示线程开始时的延迟时间,3表示周期即每3秒运行一次，TimeUnit.SECONDS
        }
        try {
            Thread.sleep(30000);//先睡眠会，在关闭线程池，否则其他线程运行不了
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            scheduledThreadpool.shutdown();//关闭线程池
        }

    }
}

运行结果：

 　　通过结果我可以发现它是周期性运行的，且在开始打印时延时了2秒，然后每过3秒重复一次。

4：newSingleThreadExecutor创建一个单线程化的线程池。（core和max都默认为1）

 

•    SingleThreadExecutor的corePoolSize和maxiumPoolSize都被设置1。

执行过程如下：

　　1.如果当前工作中的线程数量少于corePool的数量，就创建一个新的线程来执行任务。

　　2.当线程池的工作中的线程数量达到了corePool，则将任务加入LinkedBlockingQueue。

　　3.线程执行完1中的任务后会从队列中去任务。

注意：由于在线程池中只有一个工作线程，所以任务可以按照添加顺序执行。

 【代码演示】：创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class SingleThreadDemo {
    public static void main(String[] args) {
        ExecutorService singlethread=Executors.newSingleThreadExecutor();//单线程池
        for (int i = 0; i <5; i++) {
            singlethread.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }
        singlethread.shutdown();//关闭线程池
    }
}

运行结果：

 　　通过运行结果可以发现，始终只有一个线程在被反复运行着。

线程池的状态：

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static final int COUNT_BITS = Integer.SIZE - 3;  //32-3
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
// runState is stored in the high-order bits
private static final int RUNNING = -1 << COUNT_BITS;
private static final int SHUTDOWN = 0 << COUNT_BITS;
private static final int STOP = 1 << COUNT_BITS;
private static final int TIDYING = 2 << COUNT_BITS;
private static final int TERMINATED = 3 << COUNT_BITS;
// Packing and unpacking ctl
private static int runStateOf(int c) { return c & ~CAPACITY; }//获取高3位的线程状态
private static int workerCountOf(int c) { return c & CAPACITY; }//获取低29位的线程数量
private static int ctlOf(int rs, int wc) { return rs | wc; } //rs表示线程池状态，wc表示线程池中线程数量，通过两个参数可获取ctl值

　　其中ctl是一个AtomicInteger类型的属性，其提供了线程池的状态及线程池中线程的数量的统计，其中高3位用于维护线程池的运行状态，低29位用来维护线程池中线程的数量

RUNNING = -1 << COUNT_BITS；即高3位为1，低29位0，该状态的线程池可以接受新任务，也会处理阻塞队列中的任务
SHUTDOWN = 0 << COUNT_BITS：即高3位是0，低29位为0，该状态的线程池不会接受新的任务，但是会处理阻塞队列中的任务
STOP = 1 << COUNT_BITS：即高3位为001，低29位为0，该状态的线程池不会接受新任务，也不会处理阻塞队列中的任务，并且还会终止正在执行的任务
TIDYING = 2 << COUNT_BITS：即高3位为010，低29位为0，所有的任务都被终止了，线程的数量为0，还要调用terminated()方法
TERMINATED = 3 << COUNT_BITS：即高3位为011，低29位为0，terminated()方法执行之后的状态
这些状态是int类型，大小关系为RUNNING<SHUTDOWN<STOP<TIDYING<TERMINATED

 

任务提交过程：
execute()：提交任务

public void execute(Runnable command) {
　　//提交的任务不能为null
　　if (command == null)
　　　　throw new NullPointerException();

　　int c = ctl.get();
　　//判断工作线程数量小于核心线程数量
　　if (workerCountOf(c) < corePoolSize) {
　　//新创建一个线程来执行任务体====addWorker(command, true)
　　　　if (addWorker(command, true))
　　　　//添加成功，返回
　　　　return;
　　　　//添加任务失败；线程状态已经到showdown，不在接收新任务/工作线程数量大于核心线程数量
　　　　c = ctl.get();
　　}
　　//线程是运行状态，将任务添加到阻塞队列
　　if (isRunning(c) && workQueue.offer(command)) {
　　　　int recheck = ctl.get();
　　　　if (! isRunning(recheck) && remove(command))
　　　　　　reject(command);
　　　　else if (workerCountOf(recheck) == 0)
　　　　　　addWorker(null, false);
　　　　}
　　else if (!addWorker(command, false))
　　　　reject(command);
　　}

 

Java并发包中的阻塞队列一共7个，当然他们都是线程安全的。 

DealyQueue：一个使用优先级队列实现的无界阻塞队列。 　

·ArrayBlockingQueue：是一个基于数组结构的有界阻塞队列，此队列按FIFO（先进先出）原则对元素进行排序。

·LinkedBlockingQueue：一个基于链表结构的阻塞队列，此队列按FIFO排序元素，吞吐量通常要高于ArrayBlockingQueue。静态工厂方法Executors.newFixedThreadPool()使用了这个队列。

·SynchronousQueue：一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于Linked-BlockingQueue，静态工厂方法Executors.newCachedThreadPool使用了这个队列。

·PriorityBlockingQueue：一个具有优先级的无限阻塞队列

 LinkedTransferQueue：一个由链表结构组成的无界阻塞队列。 

 LinkedBlockingDeque：一个由链表结构组成的双向阻塞队列。

1.submit和execute的区别。

execute()方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功。且execute()方法输入的任务是一个Runnable类的实例。

submit()方法用于提交需要返回值的任务。线程池会返回一个future类型的对象，通过这个future对象可以判断任务是否执行成功，并且可以通过future的get()方法来获取返回值，get()方法会阻塞当前线程直到任务完成，而使用get（long timeout，TimeUnit unit）方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完

概括：

　　submit即可以提交Runnable类型的，也可以提交Callable类型的，而execute只能提交Runnable类型的。

　　submit方法具有返回值，Runnable返回的是null，Callable返回的是call方法的返回值。而execute方法不具有返回值，所以说execute方法也不能判断线程是否执行完毕。

2.shutdown和shutdownNow的区别。

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

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