文章目录
一.简介
线程池：一种使用线程的模式，存放了很多可以复用的线程，对线程统一管理。我们可以使用new的方式去创建线程，但若是并发线程太高，每个线程执行时间不长，这样频繁的创建销毁线程是比较耗费资源的，线程池就是用来解决此问题的。
1.使用线程池的优点
（1）降低资源的消耗：线程可以重复使用，不需要在创建线程和消耗线程上浪费资源；
（2）提高响应速度：任务到达时，线程可以复用已有的线程，及时响应；
（3）可管理性：无限制的创建线程会降低系统效率，线程池可以对线程进行管理、监控、调优。
二.线程池参数说明
ThreadPoolExecutor是线程池最核心的一个类，我们来看它参数最完整的构造类，代码如下：
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
| 参数名 | 含义 | 解释 |
|---|---|---|
| corePoolSize | 线程池核心线程数 | 默认情况下，线程池中是没有线程的，当还没有一次任务到达过时，初始化的线程数为0，当有任务初次来临，直接创建corePoolSize个线程；核心线程生命周期无限，即使空闲也不会死亡。 |
| maximumPoolSize | 线程池能创建的最大线程数 | 当核心线程数已满，并且工作队列也已经存放满，才会去判断当前线程数是否小于maximumPoolSize，小于则继续创建线程处理任务，等于则执行拒绝策略。 |
| keepAliveTime | 闲置超时时间 | 当线程池中的线程数大于corePoolSize时，此值才生效，即大于corePoolSize的线程在经过keepAliveTime的时间依然没有任务执行，则销毁线程。 |
| unit | 超时时间单位 | 参数keepAliveTime的单位。 |
| workQueue | 工作队列 | 当核心线程数已满时，新提交的任务放到任务队列中（前提是任务队列没满）。 |
| threadFactory | 线程池创建新线程的工厂 | 创建线程，一般默认即可。 |
| handler | 线程池达到饱和之后的拒绝策略 | 当线程数达到最大线程maximumPoolSize后（此时队列已经存满），再有新任务提交，执行的处理策略。 |
三.WorkQueue工作队列说明
workQueque决定了缓存任务的排队策略，对于不同的业务场景，我们可以选择不同的工作队列。类型为BlockingQueue，我们看下源码，哪些类实现了BlockingQueue接口。
我们来说说以下常用的四种。
1.SynchronousQueue
没有容量，直接提交队列，是无缓存等待队列，当任务提交进来，它总是马上将任务提交给线程去执行，如果线程已经达到最大，则执行拒绝策略；所以使用SynchronousQueue阻塞队列一般要求maximumPoolSize为无界（无限大），避免线程拒绝执行操作。从源码中可以看到容量为0：
//是否为空，直接返回的true
public boolean isEmpty() {
return true;
}
//队列大小为0
public int size() {
return 0;
}
2.LinkedBlockingQueue
默认情况下，LinkedBlockingQueue是个无界的任务队列，默认值是Integer.MAX_VALUE，当然我们也可以指定队列的大小。从构造LinkedBlockingQueue源码中可以看出它的大小指定方式：
//默认构造函数，大小为Integer最大
public LinkedBlockingQueue() {
this(Integer.MAX_VALUE);
}
//也可以指定大小
public LinkedBlockingQueue(int capacity) {
if (capacity <= 0) throw new IllegalArgumentException();
this.capacity = capacity;
last = head = new Node<E>(null);
}
为了避免队列过大造成机器负载，或者内存泄漏，我们在使用的时候建议手动传一个队列的大小。内部分别使用了takeLock和putLock对并发进行控制，添加和删除操作不是互斥操作，可以同时进行，这样大大提高了吞吐量。源码中有定义这两个锁：
//获取元素使用的锁
private final ReentrantLock takeLock = new ReentrantLock();
//加入元素使用的锁
private final ReentrantLock putLock = new ReentrantLock();
//获取元素时使用到takeLock锁
public E peek() {
if (count.get() == 0)
return null;
final ReentrantLock takeLock = this.takeLock;
//加锁操作
takeLock.lock();
try {
//获取元素
Node<E> first = head.next;
if (first == null)
return null;
else
return first.item;
} finally {
//解锁
takeLock.unlock();
}
}
//添加元素到队列中使用putLock锁
public boolean offer(E e) {
if (e == null) throw new NullPointerException();
final AtomicInteger count = this.count;
if (count.get() == capacity)
return false;
int c = -1;
Node<E> node = new Node<E>(e);
final ReentrantLock putLock = this.putLock;
//加锁操作
putLock.lock();
try {
//队列中存放的数据小于队列设置的值
if (count.get() < capacity) {
//添加元素
enqueue(node);
c = count.getAndIncrement();
if (c + 1 < capacity)
notFull.signal();
}
} finally {
//解锁
putLock.unlock();
}
if (c == 0)
signalNotEmpty();
return c >= 0;
}
3.ArrayBlockingQueue
可以理解为有界的队列，创建的时候必须要指定队列的大小，从源码可以看出构造的时候要传递值：
public ArrayBlockingQueue(int capacity) {
this(capacity, false);
}
4.DelayQueue
是一个延迟队列，无界、队列中每个元素都有过期时间，当从队列获取元素时，只有过期的元素才会出队，而队列头部是最早过期的元素，若是没有过期，则进行等待。利用这个特性，我们可以用来处理定时任务调用的场景，例如订单过期未支付自动取消，设置一个在队列中过期的时间，过期了后，再去查询订单的状态，若是没支付，则调用取消订单的方法。
//获取元素
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
for (;;) {
//获取元素
E first = q.peek();
if (first == null)
//进入等待
available.await();
else {
//获取过期时间
long delay = first.getDelay(NANOSECONDS);
if (delay <= 0)
//小于等于0则过期，返回此元素
return q.poll();
first = null;
if (leader != null)
available.await();
else {
Thread thisThread = Thread.currentThread();
leader = thisThread;
try {
//设置还需要等待的时间
available.awaitNanos(delay);
} finally {
if (leader == thisThread)
leader = null;
}
}
}
}
} finally {
if (leader == null && q.peek() != null)
available.signal();
lock.unlock();
}
}
四.handler四种拒绝策略说明
触发任务拒接的条件：当前同时运行的线程数量达到最大线程数maximumPoolSize，并且队列也放满了任务，即触发饱和拒绝策略。ThreadPoolExecutor中定义了四个拒绝策略内部类。
1.DiscardPolicy
当任务添加到线程池中被拒绝时，直接丢弃任务，不抛出异常，源码：
public static class DiscardPolicy implements RejectedExecutionHandler {
public DiscardPolicy() { }
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
}
}
2.AbortPolicy
当任务添加到线程池中被拒绝时，直接丢弃任务，并抛出RejectedExecutionException异常，源码：
public static class AbortPolicy implements RejectedExecutionHandler {
public AbortPolicy() { }
//不处理，直接抛出异常
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
throw new RejectedExecutionException("Task " + r.toString() +
" rejected from " +
e.toString());
}
}
3.DiscardOldestPolicy
当任务添加到线程池中被拒绝时，判断线程池是否还在运行，然后获取队列，让队首（最久）的元素出队，直接抛弃，把当前任务添加执行，不出意外还是添加到队列中，除非当前这会好几个线程执行完，线程数小于了corePoolSize。
public static class DiscardOldestPolicy implements RejectedExecutionHandler {
public DiscardOldestPolicy() { }
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
//线程池还没有销毁停止
if (!e.isShutdown()) {
//获取队列，并让队列头（最久）的任务出队，丢弃队头
e.getQueue().poll();
//执行新任务，新任务再添加到队列中
e.execute(r);
}
}
}
4.CallerRunsPolicy
当任务添加到线程池中被拒绝时，判断线程池是否还在运行，直接在主线程中运行此任务，即在调用execute或者submit的方法中执行，不再使用线程池来处理此任务。
public static class CallerRunsPolicy implements RejectedExecutionHandler {
public CallerRunsPolicy() { }
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
//线程池还在运行
if (!e.isShutdown()) {
//让主进程来运行此任务
r.run();
}
}
}
为了说明这一点，来看一个demo：
public static void main(String[] args) {
//最大线程数设置为2，队列最大能存2，使用主线程执行的拒绝策略
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,2,10, TimeUnit.SECONDS,new LinkedBlockingQueue<>(2),new ThreadPoolExecutor.CallerRunsPolicy());
//此时有6个任务，最大线程+队列能处理4个，主线程需要处理6-4=2个
for(int i = 0; i < 6;i ++) {
Runnable run = new Runnable(){
@Override
public void run() {
try {
Thread.sleep(10);
System.out.println("执行当前任务的线程："+Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
threadPoolExecutor.execute(run);
}
}
执行结果：
五.线程池处理任务策略说明
1.如果当前线程池中的线程数量小于corePoolSize，则会创建一个线程执行此任务；
2.如果当前线程池中的线程数量大于corePoolSize，则会尝试将其添加到队列中，若添加成功，则该任务会排队等待线程将其取出进行执行；若队列中已达最大值，则添加失败，则会尝试创建新的线程执行这个任务；
3.如果当前线程池中的线程数量已经达到maximumPoolSize，则尝试创建新的线程结果为false，会采取任务拒绝策略；
4.如果线程池中线程数量大于corePoolSize，则当空闲时间超过keepAliveTime的线程，将会被终止，直到线程池数量不大于corePoolSize为止。
当提交一个新任务后，线程池的处理流程图：
来看当添加一个任务到线程池的源码：
public void execute(Runnable command) {
//执行的任务为空，直接抛出异常
if (command == null)
throw new NullPointerException();
//ctl:AtomicInteger类型，获取当前线程池中的线程数
int c = ctl.get();
//当前线程数小于核心线程数，直接创建线程执行任务
if (workerCountOf(c) < corePoolSize) {
//创建线程执行任务，从wc >= (core ? corePoolSize : maximumPoolSize)可以看出，true代表创建核心线程，false代表创建非核心线程
if (addWorker(command, true))
//创建线程成功，直接返回
return;
//没成功，重新获取当前线程数
c = ctl.get();
}
//线程池还是运行状态、并且把任务添加到队列中成功
if (isRunning(c) && workQueue.offer(command)) {
//获取下当前线程数
int recheck = ctl.get();
//若是线程池不运行了，则把当前添加的任务移出
if (! isRunning(recheck) && remove(command))
//执行拒绝策略
reject(command);
//当前运行的线程数为0，
else if (workerCountOf(recheck) == 0)
//传递空参数，不进行创建
addWorker(null, false);
}
//尝试创建线程，此时传递false，wc >= (core ? corePoolSize : maximumPoolSize)，则看线程的上限匹配maximumPoolSize
else if (!addWorker(command, false))
//创建线程失败，执行拒绝策略
reject(command);
}
六.Executors四种创建线程池方式比较
Executors类(并发包)提供了4种创建线程池的方法，这些方法最终都是通过配置ThreadPoolExecutor的不同参数，来达到不同的线程管理效果。
1.newFixedThreadPool
创建一个定长的线程池，可控制最大并发数，超出的线程进行排队等待。源码如下：
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
从源码可以看出此线程池的核心线程数、最大线程数都是nThreads，线程空闲回收时间配置也没有意义了，所以闲置时间给0，队列使用LinkedBlockingQueue无界的方式，当线程数达到nThreads后，新任务放到队列中。
下面是demo:
public static void main(String[] args) {
// 创建定长线程池
ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(4);
for (int i = 0; i < 10; i++) {
//创建任务
Runnable runnable = new Runnable(){
@Override
public void run() {
try {
Thread.sleep(3);
System.out.println("当前执行的线程为:"+Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
//任务添加到线程池
newFixedThreadPool.execute(runnable);
}
}
缺点：因为LinkedBlockingQueue是一个无界的队列，当线程数达到核心线程数时，新提交的任务会一直放到队列中，当任务很多的时候，会造成OOM(内存不足)。
2.newSingleThreadExecutor
创建一个单线程池，它只会用唯一的工作线程来执行任务，超出的线程进行排队等待。源码如下：
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
从源码可以看出此线程池的核心线程数、最大线程数都是1，线程空闲回收时间配置也没有意义了，所以闲置时间给0，队列使用LinkedBlockingQueue无界的方式，当线程数达到1后，新任务放到队列中。
下面是demo:
public static void main(String[] args) {
// 创建单线程-线程池，任务依次执行
ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 6; i++) {
//创建任务
Runnable runnable = new Runnable(){
@Override
public void run() {
System.out.println("当前执行的线程为:"+Thread.currentThread().getName());
}
};
//任务添加到线程池
newSingleThreadExecutor.execute(runnable);
}
}
缺点：因为LinkedBlockingQueue是一个无界的队列，当线程数达到核心线程数时，新提交的任务会一直放到队列中，当任务很多的时候，会造成OOM(内存不足)。
3.newCachedThreadPool
创建一个可缓存的线程池，如果线程池长度大于处理需要，则根据线程空闲时间大于60s的会进行销毁；新任务添加进来，若是没有空闲的线程复用，则会立马创建一个线程来处理，因为使用的是无缓存队列。源码如下：
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>(),
threadFactory);
}
从源码可以看出此线程池的核心线程数为0、最大线程数为无界Integer.MAX_VALUE，线程空闲回收时间60S，队列使用SynchronousQueue无缓存的方式，当有任务添加，能复用之前线程则复用，没有空闲线程则创建新线程。
下面是demo:
public static void main(String[] args) {
// 创建可缓存线程池
ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
for (int i = 0; i < 6; i++) {
//创建任务
Runnable runnable = new Runnable(){
@Override
public void run() {
try {
Thread.sleep(6);
System.out.println("当前执行的线程为:"+Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
//任务添加到线程池
newCachedThreadPool.execute(runnable);
}
}
缺点：因为最大线程数为无界，当任务很多的时候，会创建大量线程，造成OOM(内存不足)。
4.newScheduledThreadPool
创建支持定时、周期任务的线程池。源码如下：
//Executors类中
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}
//ScheduledThreadPoolExecutor类中
public ScheduledThreadPoolExecutor(int corePoolSize) {
super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
new DelayedWorkQueue());
}
从源码可以看出此线程池的核心线程数为corePoolSize、最大线程数为无界Integer.MAX_VALUE，线程空闲回收时间0S，当线程数大于corePoolSize时，有线程处理完任务后，接下来就进行销毁。队列使用DelayedWorkQueue延迟队列，可以设置延时时间，当元素达到延时时间，才从队列出队。
下面是demo:
public static void main(String[] args) {
// 创建支持定时线程池
ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(2);
for (int i = 0; i < 5; i++) {
//创建任务
Runnable runnable = new Runnable(){
@Override
public void run() {
System.out.println("当前执行的线程为:"+Thread.currentThread().getName());
}
};
//任务添加到线程池，延迟2秒后才能从队列中出队
newScheduledThreadPool.schedule(runnable, 2, TimeUnit.SECONDS);
}
}
缺点：因为最大线程数为无界，当任务很多的时候，会创建大量线程，造成OOM(内存不足)。
七.ThreadPoolExecutor方式创建线程池
为了解决Executors提供的四种快速创建线程池出现的OOM(内存不足)问题，推荐使用ThreadPoolExecutor的方式，按业务、按需创建线程池。设置合理的corePoolSize、maximumPoolSize、keepAliveTime、workQueue、handler。
如果我们设置的线程池数量太小的话，如果同一时间有大量任务需要处理，可能会导致大量任务在队列中等待，甚至出现OOM（内存不足），但是此时cpu没有得到充分的利用；如果我们设置的线程数太大，大量线程可能会存在同时挣抢CPU的情况，导致大量的上下文切换，影响CPU的执行效率。
我们可以从这两点去考虑线程池的配置：
（1）cpu密集型任务，需要线程长时间进行复杂的运算，这种类型的任务需要少创建线程，过多的线程将会频繁引起上下文切换，降低任务处理速度。
（2）io密集型任务，由于线程并不是一直在运行，可能大部分时间在等待io读取/写入数据，增加线程数量可以提高并发度，尽可能多处理任务。
下面是demo:
public static void main(String[] args) {
//最大线程数设置为2，队列最大能存2，使用主线程执行的拒绝策略
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,2,0, TimeUnit.SECONDS,new LinkedBlockingQueue<>(2),new ThreadPoolExecutor.CallerRunsPolicy());
//此时有6个任务，最大线程+队列能处理4个，主线程需要处理6-4=2个
for(int i = 0; i < 6;i ++) {
Runnable run = new Runnable(){
@Override
public void run() {
try {
Thread.sleep(10);
System.out.println("执行当前任务的线程："+Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
threadPoolExecutor.execute(run);
}
}
八.单例方式创建复用线程池
我们使用单例方式创建可复用的线程池，这样一次创建后，后续业务都使用此线程池，此线程池不关闭销毁，直到系统服务停止才销毁。来看使用内部静态类单例模式创建线程池：
public class MyThreadPool {
//内部静态类构造
private static class ThreadPoolHolder{
private static ExecutorService threadPool = new ThreadPoolExecutor(6,
10,
30,
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
}
public MyThreadPool(){
}
public static ExecutorService getInstance(){
return ThreadPoolHolder.threadPool;
}
}
业务代码中直接使用：
//从单例中获取到线程池资源
ExecutorService threadPoolExecutor = MyThreadPool.getInstance();
for(int i = 0; i < 6;i ++) {
Runnable run = new Runnable(){
@Override
public void run() {
try {
Thread.sleep(10);
System.out.println("执行当前任务的线程："+Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
threadPoolExecutor.execute(run);
}
九.任务是否需要返回值
执行的任务是否需要返回值，有些业务场景下，我们需要接收线程处理后的结果返回值。当不需要返回值的时候我们使用Runnable来创建一个任务，重写run方法，当需要接收返回值的时候，我们使用Callable来创建任务，重写call方法。具体来看看源码：
@FunctionalInterface
public interface Runnable {
//没有返回值，也不抛出异常
public abstract void run();
}
@FunctionalInterface
public interface Callable<V> {
//有返回结果，处理有问题时抛出异常
V call() throws Exception;
}
在把任务添加到线程池中也需要做区分，当不需要返回值时，直接使用execute方法添加任务；当需要接收返回值时，使用submit方法提交任务。具体来看源码：
//execute没有返回值
public void execute(Runnable command) {}
//submit使用泛型来接收返回值
<T> Future<T> submit(Callable<T> task);
没有返回值的demo：
public static void main(String[] args) {
//最大线程数设置的为2，队列最大能存2，使用主线程执行的拒绝策略
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,2,10, TimeUnit.SECONDS,new LinkedBlockingQueue<>(2),new ThreadPoolExecutor.CallerRunsPolicy());
//此时有6个任务，最大线程+队列能处理4个，主线程需要处理6-4=2个
for(int i = 0; i < 6;i ++) {
Runnable run = new Runnable(){
@Override
public void run() {
try {
Thread.sleep(10);
System.out.println("执行当前任务的线程："+Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
threadPoolExecutor.execute(run);
}
}
有返回值的demo：
public static void main(String[] args) throws ExecutionException, InterruptedException {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,2,10, TimeUnit.SECONDS,new LinkedBlockingQueue<>(2),new ThreadPoolExecutor.CallerRunsPolicy());
List<Future<String>> result = new ArrayList<Future<String>>();
for(int i = 0; i < 6;i ++) {
Callable call = new Callable(){
@Override
public String call() throws Exception {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "执行当前任务的线程："+Thread.currentThread().getName();
}
};
Future<String> objectFuture = threadPoolExecutor.submit(call);
//此处不能直接等着输出返回值，若是直接在此处输出结果值，则线程池就变成串行化的了
//System.out.println(objectFuture.get());
//需要使用一个集合来接收各个线程的处理结果值
result.add(objectFuture);
}
for(int i = 0;i < result.size() ;i++) {
System.out.println(result.get(i).get());
}
}
注意：有返回值的情况，返回的结果值需要定义一个集合来接收，不能在submit提交任务后就等着输出返回值，或者调用返回值，若是有这样的操作，会使多线程的执行变成串行化，因为线程一提交完，程序就等着输出线程一的返回值，此时线程二提交，需要排队在线程一执行完输出结果后才会去执行。
十.判断线程池是否执行完毕
在很多场景下，我们都需要判断线程池是否已经执行完所有的任务，只有执行完所有的任务，我们再接着往下执行其他处理，例如需要对线程池处理的所有数据进行二次计算或者汇总，都是需要判断线程池是否已经处理完任务。例如下面代码就是存在线程池还没有处理完，就执行了主线程的后续代码：
public static void main(String[] args) throws ExecutionException, InterruptedException {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,
2,
10,
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(2),
new ThreadPoolExecutor.CallerRunsPolicy());
for(int i = 0; i < 6;i ++) {
Runnable call = new Runnable(){
@Override
public void run() {
try {
Thread.sleep(10);
System.out.println("执行当前任务的线程："+Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
threadPoolExecutor.execute(call);
}
System.out.println("所有任务执行完成");
}
程序输出结果：
1.isTerminated
我们可以使用线程池的终止状态（TERMINATED)来判断线程池的任务是否已经全部执行完，想让线程池的状态发生变化，我们需要调用关闭线程池shutdown的方法，不然线程池会一直处于RUNNING运行状态。
来看一个demo：
public static void main(String[] args) throws ExecutionException, InterruptedException {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,
2,
10,
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(2),
new ThreadPoolExecutor.CallerRunsPolicy());
for(int i = 0; i < 6;i ++) {
Runnable call = new Runnable(){
@Override
public void run() {
try {
Thread.sleep(10);
System.out.println("执行当前任务的线程："+Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
threadPoolExecutor.execute(call);
}
//关闭线程池
threadPoolExecutor.shutdown();
while(!threadPoolExecutor.isTerminated()){ //如果没有中断就一直cas自旋等待
}
System.out.println("所有任务执行完成");
}
分析之前先来看ThreadPoolExecutor中定义的线程池5个状态：
RUNNING:运行状态，可以处理任务；
SHUTDOWN:关闭状态，此时线程池不能接受新的任务，他会等待所有排队任务执行完毕；
STOP:阻断状态，此时线程不接受新的任务，不处理排队任务，并且尝试终止正在执行的任务；
TIDYING:整理状态，此时工作的线程为0，尝试执行终止线程池的钩子函数；
TERMINATED:终止状态，已完成线程池终止。
当执行线程池的shutdown()方法时，则线程池处于SHUTDOWN状态，此时线程池不能接受新的任务，它会等待所有的排队任务执行完毕；当调用了shutdownNow（）方法时，则线程池处于STOP，此时线程池不能接受新的任务，并且会去尝试终止正在执行的任务。
2.getCompletedTaskCount
可以通过获取线程池的计划执行数、已执行完成数来判断线程池是否已执行完所有任务，如果计划执行数=已执行完成数，则线程池已经执行完成，否则未执行完成。
来看demo：
public static void main(String[] args) throws ExecutionException, InterruptedException {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,
2,
10,
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(2),
new ThreadPoolExecutor.CallerRunsPolicy());
for(int i = 0; i < 6;i ++) {
Runnable call = new Runnable(){
@Override
public void run() {
try {
Thread.sleep(10);
System.out.println("执行当前任务的线程："+Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
threadPoolExecutor.execute(call);
}
//判断计划执行任务数与已经执行完任务数是否相等来控制
while(threadPoolExecutor.getTaskCount() != threadPoolExecutor.getCompletedTaskCount()){
}
System.out.println("所有任务执行完成");
}
getTaskCount()：获取计划执行的任务总数，因为线程和任务总是动态变化的，有可能在调用此方法的时候并发新加入了任务，因此返回的值只是一个近似值；
getCompletedTaskCount()：获取已经完成任务的总数，因为线程和任务总是动态变化的，有可能在调用此方法的时候并发完成了任务，因此返回的值只是一个近似值。
3.CountDownLatch
相当于计数器，我们创建一个包含N个任务的计数器，当有任务完成时，计数器减1，直到计数器减为0时，代表所有任务都执行完成了。CountDownLatch创建之后，只能使用一次，不能重复使用。
来看demo：
public static void main(String[] args) throws ExecutionException, InterruptedException {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,
2,
10,
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(2),
new ThreadPoolExecutor.CallerRunsPolicy());
//创建一个计数器
CountDownLatch countDownLatch = new CountDownLatch(6);
for(int i = 0; i < 6;i ++) {
Runnable call = new Runnable(){
@Override
public void run() {
try {
Thread.sleep(10);
System.out.println("执行当前任务的线程："+Thread.currentThread().getName());
//计数器减1
countDownLatch.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
threadPoolExecutor.execute(call);
}
//阻塞等待，计数器的数量为0，才往下执行
countDownLatch.await();
System.out.println("所有任务执行完成");
}
countDownLatch.countDown()：计数器减去1；
countDownLatch.await()：阻塞等待，计数器的数量为0，才往下执行，其它处理业务代码可以在await（）方法之后执行。
4.CyclicBarrier
与CountDownLatch类似，可以理解为一个可以重复使用的循环计数器，可以调用reset方法将自己重置为初始状态。
来看demo：
public static void main(String[] args) throws ExecutionException, InterruptedException, BrokenBarrierException {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10,
10,
10,
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(10),
new ThreadPoolExecutor.CallerRunsPolicy());
//创建一个计数器
CyclicBarrier cyclicBarrier = new CyclicBarrier(6, new Runnable() {
@Override
public void run() {
System.out.println("所有任务执行完成");
}
});
for(int i = 0; i < 6;i ++) {
Runnable call = new Runnable(){
@Override
public void run() {
try {
Thread.sleep(1);
System.out.println("执行当前任务的线程："+Thread.currentThread().getName());
cyclicBarrier.await();
} catch (InterruptedException | BrokenBarrierException e) {
e.printStackTrace();
}
}
};
threadPoolExecutor.execute(call);
}
}
构造方法可以传递两个参数，第一个是计数器的数量，第二个是当计数器为0时，执行的事件回调方法；调用await方法时，计数器减1，线程阻塞，当计数器减为0后，才放这些线程继续往下执行，同一批次通过栅栏。
十一.项目实战使用案例
根据查询到需要处理数据的条数，来建立合适的线程池，使用CountDownLatch标识数据是否处理完。
- service层
private Object getItemList(DoravisPages doravisPages) throws Exception {
List<xx> itemIdList = doravisPages.getItemIdList(); //条目id集合
int itemNum = itemIdList.size();
int corePoolSize = 15;
int maximumPoolSize = corePoolSize;
BlockingQueue<Runnable> workQueue = null;
if(itemNum < corePoolSize) { //数量小于核心线程数
corePoolSize = itemNum;
maximumPoolSize = itemNum;
workQueue = new SynchronousQueue<Runnable>(); //无缓存队列
} else {
workQueue = new LinkedBlockingDeque<>(itemNum-corePoolSize); //指定缓冲队列大小，大小为item数量-核心线程数
}
//拒接策略都是主线程执行（不能丢数据），上面的配置要求不会存在拒接的情况
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize,
60, TimeUnit.SECONDS,
workQueue,
new ThreadPoolExecutor.CallerRunsPolicy());
List<Future<bb>> results = new ArrayList<Future<bb>>(itemNum);
// 单次计数器
CountDownLatch countDownLatch = new CountDownLatch(itemNum);
for(int i = 0;i < itemIdList.size();i++) {
//这些service都是使用@Autowired注入的service类，传递过去，作为参数在线程类中查询数据使用
OutPutTheadPoolService task = new OutPutTheadPoolService(itemIdList.get(i).getId(),countDownLatch,itemService,interaEventService,apiService,itemChildService);
//接收返回结果值
Future<bb> data = threadPoolExecutor.submit(task);
//结果值添加到集合中
results.add(data);
}
countDownLatch.await(); //等待线程执行完毕
threadPoolExecutor.shutdown(); //关闭线程池
List<bb> itemList = new ArrayList<bb>(itemNum);
for(int k = 0; k < results.size();k++) {
itemList.add(results.get(k).get());
}
return itemList;
}
2.线程处理类，实现Callable接口
public class OutPutTheadPoolService implements Callable<bb> {
private final Integer itemId;
private CountDownLatch countDownLatch;
private final ItemService itemService;
private final InteraEventService interaEventService;
private final ApiService apiService;
private final ItemChildService itemChildService;
//接收参数
public OutPutTheadPoolService(Integer itemId,CountDownLatch countDownLatch,ItemService itemService,InteraEventService interaEventService,ApiService apiService,ItemChildService itemChildService) {
this.itemId = itemId;
this.countDownLatch = countDownLatch;
this.doravisPageItemService = doravisPageItemService;
this.doravisInteraEventService = doravisInteraEventService;
this.doravisApiService = doravisApiService;
this.doravisPageItemChildService = doravisPageItemChildService;
}
@Override
public bb call() throws Exception {
bb bb = new bb();
//查询item信息
aa aa = doravisPageItemService.getPageItemById(itemId);
BeanUtils.copyProperties(aa,bb);
String json = "{itemId:"+itemId+"}";
//查询事件集合
List<cc> eventList = interaEventService.getPreviewEventListByItemId(json);
bb.setEventList(eventList);
if(2 == bb.getAssessType() && null != bb.getApiId()) {
Api api = apiService.getDoravisApiById(bb.getApiId());
bb.setDoravisApi(api);
}
//执行完一个任务，计数器减1
countDownLatch.countDown();
return bb;
}
}
239
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
