jdk中线程池的创建及使用方法？

奇了个丑八怪

已于 2023-03-11 11:50:47 修改

阅读量463

点赞数 1

文章标签： jvm java jetty spring spring boot Powered by 金山文档

于 2023-03-10 17:49:14 首次发布

本文链接：https://blog.csdn.net/zx123456_6838499/article/details/129436926

版权

ThreadPoolExecutor

先看一下ThreadPoolExecutor的继承关系

线程池状态

ThreadPoolExecutor 使用 int 的高 3 位来表示线程池状态，低 29 位表示线程数量

为什么使用一个整数的高3位来表示线程池状态？低29位表示线程数量？直接用两个整数，一个整数表示状态，一个整数表示线程数量不行吗？
答：这些信息存储在一个原子变量 ctl 中，目的是将线程池状态与线程个数合二为一，这样就可以用一次 cas 原子操作进行赋值

注意：SHUTDOWN状态相比于STOP比较温和，SHUTDOWN会处理阻塞队列任务同时，保证正在执行的线程执行完后停止，STOP是暴力停止，直接调用interrupt（）方法打断正在执行的线程任务

那么如何创建线程池呢？有两种方法，一是构造方法，二是使用该构造方法的工厂方法创建指定功能的线程池。

1.构造方法创建线程池：


public ThreadPoolExecutor(int corePoolSize,
     int maximumPoolSize,
     long keepAliveTime,
     TimeUnit unit,
     BlockingQueue<Runnable> workQueue,
     ThreadFactory threadFactory,
     RejectedExecutionHandler handler){
}
//corePoolSize 核心线程数目 (最多保留的线程数)
//maximumPoolSize 最大线程数目
//keepAliveTime 生存时间 - 针对救急线程
//unit 时间单位 - 针对救急线程
//workQueue 阻塞队列
//threadFactory 线程工厂 - 可以为线程创建时起个好名字
//handler 拒绝策略

工作方式：

jdk线程池中线程默认为懒加载的，只有当任务来了后，才会自动创建线程

当收到任务后：线程池中会创建一个线程去执行对应任务，此时看创建线程池的corePoolSize（核心线程数），加入核心线程数是2个，那么当两个任务需要被执行时，就会创建两个线程，此时如果有另外任务需要被执行，此时核心线程数已经满了，剩下的任务需要在workQueue（阻塞队列）中等待，当正在执行的线程任务执行完后，会唤醒阻塞队列中的头节点线程，去执行任务

当阻塞队列也满了呢？如果任务生产的速度小于任务执行的速度，那么阻塞队列就会被放满，此时maximumPoolSize（最大线程数）就发挥作用了，所谓最大线程数就是找临时工，当阻塞队列满了后，生产者还在生产任务，此时就需要临时创建线程去执行任务，但是临时创建线程也需要有个数量，总不能无限制创建，所以就有了最大线程数的限制，即临时线程数=最大线程数-核心线程数，如果最大线程数设置的是4，那么此时核心线程数是2，可创建临时线程数就是2了，也就是要请的最多临时工。

临时线程生命周期？临时线程不是永远存在的，在任务被执行完后，会有一个空闲时间（最大存活时间）的限制，即keepAliveTime，单位是unit。当执行完任务后空闲时间超过这个最大存活时间，线程就会被销毁

临时线程的使用条件？首先当然是要使用有界队列，如果队列没有限制，就不存在队列满，也不存在临时线程了。

拒绝策略，当队列满了，最大线程数也被占用了，还是有任务被创建出来，此时就需要执行拒绝策略了如下：

拒绝策略：

AbortPolicy 让调用者抛出 RejectedExecutionException 异常，这是默认策略

CallerRunsPolicy 让调用者运行任务

DiscardPolicy 放弃本次任务

DiscardOldestPolicy 放弃队列中最早的任务，本任务取而代之

以上时jdk自己的拒绝策略

---------------------------------------------------------------------------------------------------------------------

使用第三方框架时，框架会做一些扩展：

Dubbo 的实现，在抛出 RejectedExecutionException 异常之前会记录日志，并 dump 线程栈信息，方便定位问题

Netty 的实现，是创建一个新线程来执行任务

ActiveMQ 的实现，带超时等待（60s）尝试放入队列

PinPoint 的实现，它使用了一个拒绝策略链，会逐一尝试策略链中每种拒绝策略

2.工厂方法创建线程池：

以上是使用构造方法创建线程池，下面是使用工厂方法创建线程池

根据上面的构造方法，JDK Executors 类中提供了众多工厂方法来创建各种用途的线程池

1.newFixedThreadPool


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

特点：

核心线程数 == 最大线程数（没有救急线程被创建），因此也无需超时时间
阻塞队列是无界的，可以放任意数量的任务

使用场景：

适用于任务量已知，相对耗时的任务

2.newCachedThreadPool

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

特点

1.核心线程数是 0，最大线程数是 Integer.MAX_VALUE，救急线程的空闲生存时间是 60s，意味着：
全部都是救急线程（60s 后可以回收）
救急线程可以无限创建
2.队列采用了 SynchronousQueue 实现特点是，它没有容量，没有线程来取是放不进去的（一手交钱、一手交货）

SynchronousQueue测试代码：


SynchronousQueue<Integer> integers = new SynchronousQueue<>();

new Thread(() -> {
     try {
         log.debug("putting {} ", 1);
         integers.put(1);
         log.debug("{} putted...", 1);
         
         log.debug("putting...{} ", 2);
         integers.put(2);
         log.debug("{} putted...", 2);
     } catch (InterruptedException e) {
         e.printStackTrace();
     }
},"t1").start();
 

sleep(1);
 

new Thread(() -> {
     try {
         log.debug("taking {}", 1);
         integers.take();
     } catch (InterruptedException e) {
         e.printStackTrace();
     }
},"t2").start();
 

sleep(1);
 

new Thread(() -> {
     try {
         log.debug("taking {}", 2);
         integers.take();
     } catch (InterruptedException e) {
         e.printStackTrace();
     }
},"t3").start();

测试结果：

11:48:15.500 c.TestSynchronousQueue [t1] - putting 1
11:48:16.500 c.TestSynchronousQueue [t2] - taking 1
11:48:16.500 c.TestSynchronousQueue [t1] - 1 putted...
11:48:16.500 c.TestSynchronousQueue [t1] - putting...2
11:48:17.502 c.TestSynchronousQueue [t3] - taking 2
11:48:17.503 c.TestSynchronousQueue [t1] - 2 putted...

可以看到,当某线程想往队列中添加任务时,必须有对应的消费线程来消费时,才能够放入队列,这就相当于与队列中什么都不存储,可以把这个队列理解为一种契约,你不来取我就不能往里面放.

使用场景:

整个线程池表现为线程数会根据任务量不断增长，没有上限，当任务执行完毕，空闲 1分钟后释放线程。适合任务数比较密集，但每个任务执行时间较短的情况

3.newSingleThreadExecutor

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

特点：

里面只有一个单线程，可以看到构造方法参数最大线程数和核心线程数都是1；

使用场景：

希望多个任务排队执行。线程数固定为 1，任务数多于 1 时，会放入无界队列排队。任务执行完毕，这唯一的线程也不会被释放。

那么问题来了！既然都是单线程，为什么大费周章的再创建个线程池呢？直接使用单线程不香吗？

下面说说单线程池与单线程的区别：

自己创建的一个单线程串行执行任务，如果任务执行失败而终止那么没有任何补救措施，出错代码之后的代码就不会被执行；而单线程池会新建一个线程，继续执行后续代码，保证池的正常工作

问题又来了，是不是把newFixedThreadPool固定线程池数量设置成1，就跟这个单线程池一样了？

答案也是否定的：

Executors.newSingleThreadExecutor() 线程个数始终为1，不能修改，因为它返回的是将 ThreadPoolExecutor 对象包装后的对象

FinalizableDelegatedExecutorService 应用的是装饰器模式，只对外暴露了 ExecutorService 接口，因此不能调用 ThreadPoolExecutor 中特有的方法

Executors.newFixedThreadPool(1) 初始时为1，以后还可以修改，它返回的是 ThreadPoolExecutor 对象，

对外暴露的是 ThreadPoolExecutor 对象，可以强转后调用 setCorePoolSize 等方法进行修改

4.任务调度线程池

java.util.Timer：

在了解『任务调度线程池』功能之前，可以先了解下 java.util.Timer

Timer是在任务调度线程池功能之前出现的任务调度功能，可以实现定时功能

特点：

1.简单易用
2.但由于所有任务都是由同一个线程来调度，因此所有任务都是串行执行的，同一时间只能有一个任务在执行，前一个任务的延迟或异常都将会影响到之后的任务。
3.在任务调度线程池出现后，Timer已经被废弃

代码示例：

public static void main(String[] args) {
     Timer timer = new Timer();
     TimerTask task1 = new TimerTask() {
         @Override
         public void run() {
             log.debug("task 1");
             sleep(2);        
         }
     };
     TimerTask task2 = new TimerTask() {
         @Override    
         public void run() {
             log.debug("task 2");
         }
     };
     // 使用 timer 添加两个任务，希望它们都在 1s 后执行
     // 但由于 timer 内只有一个线程来顺序执行队列中的任务，因此『任务1』的延时，影响了『任务2』的执行
     timer.schedule(task1, 1000);
     timer.schedule(task2, 1000);
}

输出结果：

20:46:09.444 c.TestTimer [main] - start...
20:46:10.447 c.TestTimer [Timer-0] - task 1
20:46:12.448 c.TestTimer [Timer-0] - task 2

使用 ScheduledExecutorService 改写：

ScheduledExecutorService有延时任务执行和定是任务执行：

延时任务执行schedule（）：既设定任务在规定时间之后执行

ScheduledExecutorService executor = Executors.newScheduledThreadPool(2);

// 添加两个任务，希望它们都在 1s 后执行
executor.schedule(() -> {
     System.out.println("任务1，执行时间：" + new Date());
     try { Thread.sleep(2000); } catch (InterruptedException e) { }
}, 1000, TimeUnit.MILLISECONDS);

executor.schedule(() -> {
     System.out.println("任务2，执行时间：" + new Date());
}, 1000, TimeUnit.MILLISECONDS);

输出结果：

任务1，执行时间：Thu Jan 03 12:45:17 CST 2019
任务2，执行时间：Thu Jan 03 12:45:17 CST 2019

特点：

1.当线程池中线程数为多个时，可以并行执行，当线程池中线程数只有1个时，多任务串行执行
2.当任务调度线程池中某线程抛出异常时，并不会影响后续任务执行。当前任务异常不会主动显示，需要手动处理：

定时任务执行scheduleAtFixedRate（）：既设定任务每隔规定时间间隔运行任务，就是固定速率执行任务

ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);
    log.debug("start...");    
    pool.scheduleAtFixedRate(() -> {
     log.debug("running...");
}, 1, 1, TimeUnit.SECONDS);

执行结果：

21:45:43.167 c.TestTimer [main] - start...
21:45:44.215 c.TestTimer [pool-1-thread-1] - running...
21:45:45.215 c.TestTimer [pool-1-thread-1] - running...
21:45:46.215 c.TestTimer [pool-1-thread-1] - running...
21:45:47.215 c.TestTimer [pool-1-thread-1] - running...

可以看到任务是按照一定频率执行的

那么问题来了，如果任务执行时间大于任务执行时间间隔怎么办呢？请看如下测试：

ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);
    log.debug("start...");
    pool.scheduleAtFixedRate(() -> {
     log.debug("running...");
     sleep(2);
}, 1, 1, TimeUnit.SECONDS);

执行结果：

21:44:30.311 c.TestTimer [main] - start...
21:44:31.360 c.TestTimer [pool-1-thread-1] - running...
21:44:33.361 c.TestTimer [pool-1-thread-1] - running...
21:44:35.362 c.TestTimer [pool-1-thread-1] - running...
21:44:37.362 c.TestTimer [pool-1-thread-1] - running...

可以看到，任务执行间隔小于任务执行时间的话，相当于已经计时结束，当任务执行完后，直接执行后续任务，不需要再额外等待时间了。能够保证每次任务都能正常执行。

那么如果想实现给每个任务和每个任务之间添加时间间隔该如何呢？

ScheduledExecutorService中也提供了对应方法：

scheduleWithFixedDelay：保证每个任务之间的时间间隔

cheduledExecutorService pool = Executors.newScheduledThreadPool(1);
    log.debug("start...");    
    pool.scheduleWithFixedDelay(()-> {
     log.debug("running...");
     sleep(2);
}, 1, 1, TimeUnit.SECONDS);

输出：

21:40:55.078 c.TestTimer [main] - start...
21:40:56.140 c.TestTimer [pool-1-thread-1] - running...
21:40:59.143 c.TestTimer [pool-1-thread-1] - running...
21:41:02.145 c.TestTimer [pool-1-thread-1] - running...
21:41:05.147 c.TestTimer [pool-1-thread-1] - running...

输出分析：一开始，延时 1s，scheduleWithFixedDelay 的间隔是上一个任务结束 <-> 延时 <-> 下一个任务开始所以间隔都是 3s

整个线程池表现为：线程数固定，任务数多于线程数时，会放入无界队列排队。任务执行完毕，这些线程也不会被释放。用来执行延迟或反复执行的任务

如何正确处理线程池异常？

方法一：使用try...catch进行手动异常捕捉：

ExecutorService pool = Executors.newFixedThreadPool(1);
    pool.submit(() -> {
     try {
         log.debug("task1");
         int i = 1 / 0;
     } catch (Exception e) {
         log.error("error:", e);
     }
});

输出：

21:59:04.558 c.TestTimer [pool-1-thread-1] - task1 
21:59:04.562 c.TestTimer [pool-1-thread-1] - error: 
java.lang.ArithmeticException: / by zero 
     at cn.itcast.n8.TestTimer.lambda$main$0(TestTimer.java:28) 
     at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511) 
     at java.util.concurrent.FutureTask.run(FutureTask.java:266) 
     at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149) 
     at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624) 
     at java.lang.Thread.run(Thread.java:748)

方法2：使用 Future

ExecutorService pool = Executors.newFixedThreadPool(1);
    Future<Boolean> f = pool.submit(() -> {
     log.debug("task1");
     int i = 1 / 0;
     return true;
    });
log.debug("result:{}", f.get());

输出

21:54:58.208 c.TestTimer [pool-1-thread-1] - task1 
Exception in thread "main" java.util.concurrent.ExecutionException: 
java.lang.ArithmeticException: / by zero 
     at java.util.concurrent.FutureTask.report(FutureTask.java:122) 
     at java.util.concurrent.FutureTask.get(FutureTask.java:192) 
     at cn.itcast.n8.TestTimer.main(TestTimer.java:31) 
    Caused by: java.lang.ArithmeticException: / by zero 
     at cn.itcast.n8.TestTimer.lambda$main$0(TestTimer.java:28) 
     at java.util.concurrent.FutureTask.run(FutureTask.java:266) 
     at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149) 
     at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624) 
     at java.lang.Thread.run(Thread.java:748)

可以看到Future使用很是方便，适用与所有线程池的异常捕捉，并将异常信息进行记录打印，可以定位到具体哪个类，哪个方法，哪一行出现问题；

3提交任务

以上就是线程池的创建方法，那么线程池创建好之后，任务该怎么执行呢？那就需要调用线程池对象的任务提交方法了，任务提交方法有多种：

execute方法

void execute(Runnable command);

参数类型为Runnable，调用该方法后，线程池就开始执行对应的任务

特点：无返回值，不能接受到线程的执行结果，就是线程任务都执行完了，但是你无法通过代码去查看任务的执行状况；

submit方法

<T> Future<T> submit(Callable<T> task);

//保存结果
Future<String> future = pool.submit(() -> {
            //..线程任务代码
            return "返回执行结果";
        });

//接收结果：
future.get();//获得执行结果

特点：

参数类型为Callable类型，可以使用返回值 Future 获得任务执行结果，返回类型可以由泛型定义，通过future.get();获得执行结果；

invokeAll方法

重载方法一：

<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
     throws InterruptedException;

特点：提交一个任务集合并执行。

invokeAll代码实现：

private static void testInvokeAll(ExecutorService pool) throws InterruptedException {
        List<Future<String>> futures = pool.invokeAll(Arrays.asList(
                () -> {
                    log.debug("begin");
                    Thread.sleep(1000);
                    return "1";
                },
                () -> {
                    log.debug("begin");
                    Thread.sleep(500);
                    return "2";
                },
                () -> {
                    log.debug("begin");
                    Thread.sleep(2000);
                    return "3";
                }
        ));

        futures.forEach( f ->  {
            try {
                log.debug("{}", f.get());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        });
    }

重载方法二：

<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
     long timeout, TimeUnit unit)
     throws InterruptedException;

特点：原理同重载方法一，但是多了一个超时时间的限定，当任务执行超过规定时间后还没有执行完的话，自动放弃剩余的任务。

invokeAny方法

重载方法一：

<T> T invokeAny(Collection<? extends Callable<T>> tasks)
     throws InterruptedException, ExecutionException;

特点：提交任务集合，哪个任务先执行完毕，返回此任务执行结果，其它任务取消；

这是一个存在竞争关系的方法，就像是百米赛跑，就要第一名，谁第一个到终点，谁获胜，其余的全部淘汰！

重载方法二：

<T> T invokeAny(Collection<? extends Callable<T>> tasks,
     long timeout, TimeUnit unit)
     throws InterruptedException, ExecutionException, TimeoutException;

特点：提交任务集合，哪个任务先成功执行完毕，返回此任务执行结果，其它任务取消，带超时时间

4.关闭线程池

shutdown方法：

void shutdown();

特点：

线程池状态变为 SHUTDOWN
- 不会接收新任务
- 但已提交任务会执行完（当前正在执行的任务和阻塞队列中的任务都会执行完毕）
- 此方法不会阻塞调用线程的执行

方法实现：

public void shutdown() {
     final ReentrantLock mainLock = this.mainLock;
     mainLock.lock();
     try {
         checkShutdownAccess();
         // 修改线程池状态    
         advanceRunState(SHUTDOWN);
         // 仅会打断空闲线程    
         interruptIdleWorkers();
         onShutdown(); // 扩展点 ScheduledThreadPoolExecutor    
     } finally {
         mainLock.unlock();
     }
     // 尝试终结(没有运行的线程可以立刻终结，
    //如果还有运行的线程也不会等，先终结，让正在运行的线程执行完任务后自己结束)    
     tryTerminate();
}

shutdownNow方法：

List<Runnable> shutdownNow();

特点：

线程池状态变为 STOP
- 不会接收新任务，并停止所有正在执行任务
- 会将阻塞队列中的任务返回：List<Runnable>
- 正在执行的任务会用 interrupt 的方式中断

方法实现：

public List<Runnable> shutdownNow() {
     List<Runnable> tasks;
     final ReentrantLock mainLock = this.mainLock;
     mainLock.lock();
     try {
         checkShutdownAccess();
         // 修改线程池状态        
         advanceRunState(STOP);
         // 打断所有线程        
         interruptWorkers();
         // 获取队列中剩余任务        
         tasks = drainQueue();
     } finally {
         mainLock.unlock();
     }
     // 尝试终结    
     tryTerminate();
     return tasks;//返回剩余任务
}

其他方法

// 不在 RUNNING 状态的线程池，此方法就返回 true
boolean isShutdown();
 
// 线程池状态是否是 TERMINATED
boolean isTerminated();
 
// 调用 shutdown 后，由于调用线程并不会等待所有任务运行结束，
//因此如果它想在线程池 TERMINATED 后做些事情，可以利用此方法等待
boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;