通过上一篇：配置@Async异步工作的线程池的介绍，你应该曾经理解到异步工作的执行背地有一个线程池来治理执行工作。为了管制异步工作的并发不影响到利用的失常运作，咱们必须要对线程池做好相应的配置，避免资源的过渡应用。除了默认线程池的配置之外，还有一类场景，也是很常见的，那就是多任务状况下的线程池隔离。
什么是线程池的隔离，为什么要隔离
可能有的小伙伴还不太理解什么是线程池的隔离，为什么要隔离？。所以，咱们先来看看上面的场景案例：
@RestControllerpublic class HelloController { @Autowired private AsyncTasks asyncTasks; @GetMapping("/api-1") public String taskOne() { CompletableFuture<String> task1 = asyncTasks.doTaskOne("1"); CompletableFuture<String> task2 = asyncTasks.doTaskOne("2"); CompletableFuture<String> task3 = asyncTasks.doTaskOne("3"); CompletableFuture.allOf(task1, task2, task3).join(); return ""; } @GetMapping("/api-2") public String taskTwo() { CompletableFuture<String> task1 = asyncTasks.doTaskTwo("1"); CompletableFuture<String> task2 = asyncTasks.doTaskTwo("2"); CompletableFuture<String> task3 = asyncTasks.doTaskTwo("3"); CompletableFuture.allOf(task1, task2, task3).join(); return ""; } }下面的代码中，有两个API接口，这两个接口的具体执行逻辑中都会把执行过程拆分为三个异步工作来实现。
好了，思考一分钟，想一下。如果这样实现，会有什么问题吗？
下面这段代码，在API申请并发不高，同时如果每个工作的处理速度也够快的时候，是没有问题的。但如果并发上来或其中某几个处理过程扯后腿了的时候。这两个提供不相干服务的接口可能会相互影响。比方：假如以后线程池配置的最大线程数有2个，这个时候/api-1接口中task1和task2处理速度很慢，阻塞了；那么此时，当用户调用api-2接口的时候，这个服务也会阻塞！
造成这种现场的起因是：默认状况下，所有用@Async创立的异步工作都是共用的一个线程池，所以当有一些异步工作碰到性能问题的时候，是会间接影响其余异步工作的。
为了解决这个问题，咱们就须要对异步工作做肯定的线程池隔离，让不同的异步工作互不影响。
不同异步工作配置不同线程池
上面，咱们就来实际操作一下！
第一步：初始化多个线程池，比方上面这样：
@EnableAsync@Configurationpublic class TaskPoolConfig { @Bean public Executor taskExecutor1() { ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); executor.setCorePoolSize(2); executor.setMaxPoolSize(2); executor.setQueueCapacity(10); executor.setKeepAliveSeconds(60); executor.setThreadNamePrefix("executor-1-"); executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); return executor; } @Bean public Executor taskExecutor2() { ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); executor.setCorePoolSize(2); executor.setMaxPoolSize(2); executor.setQueueCapacity(10); executor.setKeepAliveSeconds(60); executor.setThreadNamePrefix("executor-2-"); executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); return executor; }}留神：这里顺便用executor.setThreadNamePrefix设置了线程名的前缀，这样能够不便察看前面具体执行的程序。第二步：创立异步工作，并指定要应用的线程池名称
@Slf4j@Componentpublic class AsyncTasks { public static Random random = new Random(); @Async("taskExecutor1") public CompletableFuture<String> doTaskOne(String taskNo) throws Exception { log.info("开始工作：{}", taskNo); long start = System.currentTimeMillis(); Thread.sleep(random.nextInt(10000)); long end = System.currentTimeMillis(); log.info("实现工作：{}，耗时：{} 毫秒", taskNo, end - start); return CompletableFuture.completedFuture("工作实现"); } @Async("taskExecutor2") public CompletableFuture<String> doTaskTwo(String taskNo) throws Exception { log.info("开始工作：{}", taskNo); long start = System.currentTimeMillis(); Thread.sleep(random.nextInt(10000)); long end = System.currentTimeMillis(); log.info("实现工作：{}，耗时：{} 毫秒", taskNo, end - start); return CompletableFuture.completedFuture("工作实现"); }}这里@Async注解中定义的taskExecutor1和taskExecutor2就是线程池的名字。因为在第一步中，咱们没有具体写两个线程池Bean的名称，所以默认会应用办法名，也就是taskExecutor1和taskExecutor2。
第三步：写个单元测试来验证下，比方上面这样：
@Slf4j@SpringBootTestpublic class Chapter77ApplicationTests { @Autowired private AsyncTasks asyncTasks; @Test public void test() throws Exception { long start = System.currentTimeMillis(); // 线程池1 CompletableFuture<String> task1 = asyncTasks.doTaskOne("1"); CompletableFuture<String> task2 = asyncTasks.doTaskOne("2"); CompletableFuture<String> task3 = asyncTasks.doTaskOne("3"); // 线程池2 CompletableFuture<String> task4 = asyncTasks.doTaskTwo("4"); CompletableFuture<String> task5 = asyncTasks.doTaskTwo("5"); CompletableFuture<String> task6 = asyncTasks.doTaskTwo("6"); // 一起执行 CompletableFuture.allOf(task1, task2, task3, task4, task5, task6).join(); long end = System.currentTimeMillis(); log.info("工作全副实现，总耗时：" + (end - start) + "毫秒"); }}在下面的单元测试中，一共启动了6个异步工作，前三个用的是线程池1，后三个用的是线程池2。
先不执行，依据设置的外围线程2和最大线程数2，来剖析一下，大略会是怎么样的执行状况？
- 线程池1的三个工作，task1和task2会先取得执行线程，而后task3因为没有可调配线程进入缓冲队列
- 线程池2的三个工作，task4和task5会先取得执行线程，而后task6因为没有可调配线程进入缓冲队列
- 工作task3会在task1或task2实现之后，开始执行
- 工作task6会在task4或task5实现之后，开始执行
剖析好之后，执行下单元测试，看看是否是这样的：
2021-09-15 23:45:11.369 INFO 61670 --- [ executor-1-1] com.didispace.chapter77.AsyncTasks : 开始工作：12021-09-15 23:45:11.369 INFO 61670 --- [ executor-2-2] com.didispace.chapter77.AsyncTasks : 开始工作：52021-09-15 23:45:11.369 INFO 61670 --- [ executor-2-1] com.didispace.chapter77.AsyncTasks : 开始工作：42021-09-15 23:45:11.369 INFO 61670 --- [ executor-1-2] com.didispace.chapter77.AsyncTasks : 开始工作：22021-09-15 23:45:15.905 INFO 61670 --- [ executor-2-1] com.didispace.chapter77.AsyncTasks : 实现工作：4，耗时：4532 毫秒2021-09-15 23:45:15.905 INFO 61670 --- [ executor-2-1] com.didispace.chapter77.AsyncTasks : 开始工作：62021-09-15 23:45:18.263 INFO 61670 --- [ executor-1-2] com.didispace.chapter77.AsyncTasks : 实现工作：2，耗时：6890 毫秒2021-09-15 23:45:18.263 INFO 61670 --- [ executor-1-2] com.didispace.chapter77.AsyncTasks : 开始工作：32021-09-15 23:45:18.896 INFO 61670 --- [ executor-2-2] com.didispace.chapter77.AsyncTasks : 实现工作：5，耗时：7523 毫秒2021-09-15 23:45:19.842 INFO 61670 --- [ executor-1-2] com.didispace.chapter77.AsyncTasks : 实现工作：3，耗时：1579 毫秒2021-09-15 23:45:20.551 INFO 61670 --- [ executor-1-1] com.didispace.chapter77.AsyncTasks : 实现工作：1，耗时：9178 毫秒2021-09-15 23:45:24.117 INFO 61670 --- [ executor-2-1] com.didispace.chapter77.AsyncTasks : 实现工作：6，耗时：8212 毫秒2021-09-15 23:45:24.117 INFO 61670 --- [ main] c.d.chapter77.Chapter77ApplicationTests : 工作全副实现，总耗时：12762毫秒好了，明天的学习就到这里！如果您学习过程中如遇艰难？能够退出咱们超高品质的Spring技术交换群，参加交换与探讨，更好的学习与提高！更多Spring Boot教程能够点击中转！，欢送珍藏与转发反对！
代码示例
本文的残缺工程能够查看上面仓库中2.x目录下的chapter7-7工程：
- Github：https://github.com/dyc87112/SpringBoot-Learning/
- Gitee：https://gitee.com/didispace/SpringBoot-Learning/
如果您感觉本文不错，欢送Star反对，您的关注是我保持的能源！
欢送关注我的公众号：程序猿DD，分享其余中央看不到的常识与思考