JAVA阻塞队列与线程池

一、阻塞队列

阻塞队列与普通队列的最大区别，在于它提供了阻塞式的添加和删除：

阻塞式添加

当阻塞队列元素已满时，队列会阻塞加入元素的线程，直队列元素不满时才重新唤醒线程执行加入操作。

阻塞式删除
在队列元素为空时，删除队列元素的线程将被阻塞，直到队列不为空再执行删除操作，一般都会返回被删除的元素。

阻塞队列接口BlockingQueue继承自Queue接口，它提供的主要方法有

插入方法：

• add(E e) : 添加成功返回true，失败抛IllegalStateException异常
• offer(E e) : 成功返回 true，如果此队列已满，则返回 false。
• put(E e) :将元素插入此队列的尾部，如果该队列已满，则一直阻塞

删除方法:

• remove(Object o) :移除指定元素,成功返回true，失败返回false
• poll() : 获取并移除此队列的头元素，若队列为空，则返回 null
• take()：获取并移除此队列头元素，若没有元素则一直阻塞。

检查方法

• element() ：获取但不移除此队列的头元素，没有元素则抛异常
• peek() :获取但不移除此队列的头；若队列为空，则返回 null。

阻塞队列中的两个实现类ArrayBlockingQueue和LinkedBlockingQueue

ArrayBlockingQueue 是一个用数组实现的有界阻塞队列，其内部按先进先出的原则对元素进行排序，其中put方法和take方法为添加和删除的阻塞方法

LinkedBlockingQueue是一个基于链表的阻塞队列，其内部维持一个基于链表的数据队列，实际上我们对LinkedBlockingQueue的API操作都是间接操作该数据队列

LinkedBlockingQueue和ArrayBlockingQueue区别：

1.队列大小有所不同，ArrayBlockingQueue是有界的初始化必须指定大小，而LinkedBlockingQueue可以是有界的也可以是无界的(Integer.MAX_VALUE)，对于后者而言，当添加速度大于移除速度时，在无界的情况下，可能会造成内存溢出等问题。

2.数据存储容器不同，ArrayBlockingQueue采用的是数组作为数据存储容器，而LinkedBlockingQueue采用的则是以Node节点作为连接对象的链表。

3.由于ArrayBlockingQueue采用的是数组的存储容器，因此在插入或删除元素时不会产生或销毁任何额外的对象实例，而LinkedBlockingQueue则会生成一个额外的Node对象。这可能在长时间内需要高效并发地处理大批量数据的时，对于GC可能存在较大影响。

4.两者的实现队列添加或移除的锁不一样，ArrayBlockingQueue实现的队列中的锁是没有分离的，即添加操作和移除操作采用的同一个ReenterLock锁，而LinkedBlockingQueue实现的队列中的锁是分离的，其添加采用的是putLock，移除采用的则是takeLock，这样能大大提高队列的吞吐量，也意味着在高并发的情况下生产者和消费者可以并行地操作队列中的数据，以此来提高整个队列的并发性能。

另外两种阻塞队列：

SynchronousQueue是一个不存储元素的阻塞队列，每个插入的操作必须等待另一个线程进行相应的删除操作，反之亦然，因此这里的Synchronous指的是读线程和写线程需要同步，一个读线程匹配一个写线程。

该类还支持可供选择的公平性策略，针对不同的公平性策略有两种不同的Transfer实现，TransferQueue实现公平模式和TransferStack实现非公平模式。

take和put操作都调用了transfer核心方法，根据传入的参数e是否为null来对应处理。

DelayQueue内部使用优先级队列，因此是一个延迟队列，其在指定时间才能获取队列元素，队列头元素是最接近过期的元素。没有过期元素的话，使用poll()方法会返回null值，超时判定是通过getDelay(TimeUnit.NANOSECONDS)方法的返回值小于等于0来判断。延时队列不能存放空元素。

二、线程池

1、为什么使用线程池？

1. 降低系统资源消耗，通过重用已存在的线程，降低线程创建和销毁造成的消耗；
2. 提高系统响应速度，当有任务到达时，通过复用已存在的线程，无需等待新线程的创建便能立即执行；
3. 方便线程并发数的管控。因为线程若是无限制的创建，可能会导致内存占用过多而产生OOM。

2、线程池的构造方法与执行流程

JAVA提供线程池的构造方法

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), defaultHandler);
}

一共有7个参数，他们的含义是：

• corePoolSize：核心池的大小。默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务（除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法预创建线程）。当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中。
• maximumPoolSize：线程池最大线程数，它表示在线程池中最多能创建多少个线程。当队列满了，且已创建的线程数小于maximumPoolSize，则线程池会创建新的线程来执行任务。另外，对于无界队列，可忽略该参数。
• keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0。
• unit：参数keepAliveTime的时间单位。
• workQueue：一个阻塞队列，用来存储等待执行的任务。
• threadFactory：线程工厂，用来创建线程。
• handler：线程饱和策略，表示当线程池已经饱和导致拒绝处理任务时的策略，有以下四种取值：

ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。默认值。

ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。

ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）。

ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务。

线程池的添加任务流程图：

线程池为什么需要使用（阻塞）队列？

1、创建线程池的消耗较高

2、因为线程若是无限制的创建，可能会导致内存占用过多而产生OOM

3、阻塞队列主要是用于生产者-消费者模型的情况：当一个线程从一个空的阻塞队列中取元素，此时线程会被阻塞直到阻塞队列中有了元素。当队列中有元素后，被阻塞的线程会自动被唤醒（不需要我们编。这样提供了极大的方便性。如果使用非阻塞队列，它不会对当前线程产生阻塞，就必须额外地实现同步策略以及线程间唤醒策略，这个实现起来就非常麻烦。

3、线程池的状态

1. RUNNING, 运行状态，刚创建的线程池就是此状态。
2. SHUTDOWN，停工状态，不再接收新任务，已经接收的会继续执行。
3. STOP，停止状态，不再接收新任务，已经接收正在执行的，也会中断。
4. TERMINATED，终止状态，线程池已销毁。

4、执行方法execute、submit

向线程池提交任务有这2种方式，

1、execute()，执行一个任务，没有返回值。
2、submit()，提交一个线程任务，有返回值。submit是将要执行的任务包装为FutureTask来提交，使用者可以通过FutureTask来拿到任务的执行状态和执行最终的结果，最终调用的都是execute方法。

• submit(Callable<T> task)，能获取到它的返回值，通过future.get()获取（阻塞直到任务执行完）。一般使用FutureTask+Callable配合使用（。
• submit(Runnable task, T result)，能通过传入的载体result间接获得线程的返回值。
• submit(Runnable task)，则是没有返回值的，就算获取它的返回值也是null。

Future.get()方法会使取结果的线程进入阻塞状态，知道线程执行完成之后，唤醒取结果的线程，然后返回结果。

5、关闭线程池

ThreadPoolExecutor提供了两个方法，用于线程池的关闭，分别是shutdown()和shutdownNow()

• shutdown()：不会立即终止线程池，而是要等所有任务缓存队列中的任务都执行完后才终止，但再也不会接受新的任务
• shutdownNow()：立即终止线程池，并尝试打断正在执行的任务，并且清空任务缓存队列，返回尚未执行的任务

6、java中提供的线程池

Executors类提供了4种不同的线程池：newCachedThreadPool, newFixedThreadPool, newScheduledThreadPool, newSingleThreadExecutor：

newCachedThreadPool

• 创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。

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

newFixedThreadPool

• 创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大的大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

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

SingleThreadExecutor

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

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

newScheduledThreadPool

• 适用于需要单个后台线程执行周期任务，同时需要保证顺序地执行各个任务的应用场景。

创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。有三种提交任务的方式：
schedule：延迟多长时间之后只执行一次；
scheduledAtFixedRate：延迟指定时间后执行一次，之后按照固定的时长周期执行；
scheduledWithFixedDelay：延迟指定时间后执行一次，之后按照：上一次任务执行时长 + 周期的时长 的时间去周期执行；

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

在java doc中，并不提倡我们直接使用ThreadPoolExecutor，而是建议使用Executors类中提供的几个静态方法来创建线程池，

但是，我们可以看到上面的四种线程池它们有一个参数阻塞队列：newFixedThreadPool()跟newSingleThreadPool()一样，传入的都是相当于无界的一个队列，而newCachedThreadPool()和newScheduledThreadPool()可以看到传入的一个最大线程数为Integer.MAX_VALUE，也就是会一直创建新的线程去执行任务，这时候服务器也是承受不住的，会造成服务器崩溃。队列。

所以我们应该使用底层的ThreadPoolExecutor()类创建线程池，这样自己能够清楚的知道自己设置线程池和队列大小，设计出符合自己需要的线程池。

 

7、如何配置线程池

• CPU密集型任务

尽量使用较小的线程池，一般为CPU核心数+1。 因为CPU密集型任务使得CPU使用率很高，若开过多的线程数，会造成CPU过度切换。

• IO密集型任务

可以使用稍大的线程池，一般为2*CPU核心数。 IO密集型任务CPU使用率并不高，因此可以让CPU在等待IO的时候有其他线程去处理别的任务，充分利用CPU时间。

当然，这只是一个参考值，具体的设置还需要根据实际情况进行调整，比如可以先将线程池大小设置为参考值，再观察任务运行情况和系统负载、资源利用率来进行适当调整。