9.1 Callable 接口

  1. package s02.e09;
  3. import java.util.concurrent.Callable;
  5. class MyThread implements Runnable {
  6.     @Override
  7.     public void run() {
  8.     }
  9. }
  11. class MyThread2 implements Callable<Integer> {
  12.     @Override
  13.     public Integer call() throws Exception {
  14.         return null;
  15.     }
  16. }
  19. public class CallableDemo {
  20. }

Callable 接口与 Runnable 接口区别

  1. Callable 接口带返回值，Runnable 接口不带
  2. Callable 接口会抛异常，可以返回错误信息
  3. 接口实现方法不一样 ```java package s02.e09;

import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask;

class MyThread implements Callable { @Override public Integer call() throws Exception { System.out.println(“*come in callable”); return 1024; } }

public class CallableDemo { public static void main(String[] args) throws ExecutionException, InterruptedException { // FutureTask (CalLabLe callabLe) FutureTask futureTask = new FutureTask<>(new MyThread()); Thread t1 = new Thread(futureTask, “AA”); t1.start();

  1.     int result01 = 100;
  2.     int result02 = futureTask.get();
  3.     System.out.println("******result: " + (result01 + result02));
  5. }

}

  1. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/390086/1645288682195-4aaff466-2b36-47b6-afbb-ba43f0a3ac0e.png#clientId=uf4e5c8b9-2673-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=46&id=u32a947df&margin=%5Bobject%20Object%5D&name=image.png&originHeight=46&originWidth=230&originalType=binary&ratio=1&rotation=0&showTitle=false&size=3041&status=done&style=none&taskId=u347fe776-e4a2-47b6-94f6-1f406956bd7&title=&width=230)
  2. <a name="w3ANo"></a>
  3. # 9.2 为什么要用 Callable 接口
  4. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/390086/1645288660102-718b518c-b013-48c6-ac15-2391cb7b3ce1.png#clientId=uf4e5c8b9-2673-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=402&id=u9ca3f925&margin=%5Bobject%20Object%5D&name=image.png&originHeight=402&originWidth=1202&originalType=binary&ratio=1&rotation=0&showTitle=false&size=48813&status=done&style=none&taskId=u933a6113-33b6-465d-ab96-a7d82439ae5&title=&width=1202)<br />分治思想，可以将耗时的任务单独去处理，最后将结果获取。<br />【注意】
  6. 1. 获得 callable 线程的计算结果代码放在最后，如果没有计算完成就要去强求，会导致堵塞
  7. ```java
  8. package s02.e09;
  10. import java.util.concurrent.Callable;
  11. import java.util.concurrent.ExecutionException;
  12. import java.util.concurrent.FutureTask;
  13. import java.util.concurrent.TimeUnit;
  15. class MyThread implements Callable<Integer> {
  16.     @Override
  17.     public Integer call() throws Exception {
  18.         System.out.println("***********come in callable");
  19.         // 暂停一会儿线程
  20.         try {
  21.             TimeUnit.SECONDS.sleep(2);
  22.         } catch (InterruptedException e) {
  23.             e.printStackTrace();
  24.         }
  25.         return 1024;
  26.     }
  27. }
  29. public class CallableDemo {
  30.     public static void main(String[] args) throws ExecutionException, InterruptedException {
  31.         // 两个线程，一个 main 主线程，一个是 AA futuceTask
  32.         // FutureTask (CalLabLe<v> callabLe)
  33.         FutureTask<Integer> futureTask = new FutureTask<>(new MyThread());
  34.         new Thread(futureTask, "AA").start();
  35.         int result02 = futureTask.get(); // 线程阻塞
  37.         System.out.println(Thread.currentThread().getName() + "****************");
  38.         int result01 = 100;
  39.         System.out.println("******result: " + (result01 + result02));
  40.     }
  41. }

image.png
第二行等了 2 秒才打印

  1. 通过 while 精确等待 futureTask 计算完结果后再获取，类似自旋锁 ```java package s02.e09;

import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; import java.util.concurrent.TimeUnit;

class MyThread implements Callable { @Override public Integer call() throws Exception { System.out.println(“*come in callable”); // 暂停一会儿线程 try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); } return 1024; } }

public class CallableDemo { public static void main(String[] args) throws ExecutionException, InterruptedException { // 两个线程，一个 main 主线程，一个是 AA futuceTask // FutureTask (CalLabLe callabLe) FutureTask futureTask = new FutureTask<>(new MyThread()); new Thread(futureTask, “AA”).start();

  1.     System.out.println(Thread.currentThread().getName() + "****************");
  2.     int result01 = 100;
  4.     while (!futureTask.isDone()) {
  6.     }
  8.     int result02 = futureTask.get();
  9.     System.out.println("******result: " + (result01 + result02));
  11. }

}

  2. 3. 多个线程抢 futureTask，计算结果只算一次
  3. ```java
  4. package s02.e09;
  6. import java.util.concurrent.Callable;
  7. import java.util.concurrent.ExecutionException;
  8. import java.util.concurrent.FutureTask;
  9. import java.util.concurrent.TimeUnit;
  11. class MyThread implements Callable<Integer> {
  12.     @Override
  13.     public Integer call() throws Exception {
  14.         System.out.println(Thread.currentThread().getName() + " ***********come in callable");
  15.         // 暂停一会儿线程
  16.         try {
  17.             TimeUnit.SECONDS.sleep(2);
  18.         } catch (InterruptedException e) {
  19.             e.printStackTrace();
  20.         }
  21.         return 1024;
  22.     }
  23. }
  25. public class CallableDemo {
  26.     public static void main(String[] args) throws ExecutionException, InterruptedException {
  27.         // 两个线程，一个 main 主线程，一个是 AA futuceTask
  28.         // FutureTask (CalLabLe<v> callabLe)
  29.         FutureTask<Integer> futureTask = new FutureTask<>(new MyThread());
  30.         new Thread(futureTask, "AA").start();
  31.         new Thread(futureTask, "BB").start();
  33.         System.out.println(Thread.currentThread().getName() + "****************");
  34.         int result01 = 100;
  36.         while (!futureTask.isDone()) {
  38.         }
  40.         int result02 = futureTask.get();
  41.         System.out.println("******result: " + (result01 + result02));
  43.     }
  44. }

image.png

9.3 线程池使用及优势

线程池做的工作主要是控制运行的线程的数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量超出数量的线程排队等候，等其它线程执行完毕，再从队列中取出任务来执行。
他的主要特点为：线程复用；控制最大并发数；管理线程。
第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
第二：提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
第三：提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控

9.4 线程池常用 3 种方式

Java 中的线程池是通过 Executor 框架实现的，该框架中用到了 Executor，Executors，ExecutorService，ThreadPoolExecutor 这几个类。
image.png

  1. Executors.newScheduledThreadPool()
  2. java8 新出——Executors.newWorkStealingPool(int)

java8 新增，使用目前机器上可用的处理器作为它的并行级别

  1. Executors.newFixedThreadPool(int) —— 执行长期的任务，性能好很多
    Executors.newSingleThreadExecutor() —— 一个任务一个任务执行的场景
    Executors.newCachedThreadPool() —— 适用：执行很多短期异步的小程序或者负载较轻的服务器

    9.4.1 newFixedThreadPool

    ```java package s02.e09;

import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors;

public class MyThreadPoolDemo { public static void main(String[] args) { ExecutorService threadPool = Executors.newFixedThreadPool(5); // 一池 5 个处理线程。 try { // 模拟 10 个用户来办理业务，每个用户就是一个来自外部的请求线程 for (int i = 1; i <= 10; i++) { threadPool.execute(() -> { System.out.println(Thread.currentThread().getName() + “\t办理业务”); }); } } catch (Exception e) { e.printStackTrace(); } finally { threadPool.shutdown(); } } }

  1. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/390086/1645371225683-4c1ff8e9-e5b3-49e9-bcb9-b99e4f03e6cc.png#clientId=u82040053-338f-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=224&id=u42d87946&margin=%5Bobject%20Object%5D&name=image.png&originHeight=224&originWidth=198&originalType=binary&ratio=1&rotation=0&showTitle=false&size=6627&status=done&style=none&taskId=uac3eb808-fb00-4c50-acf6-28b973fe243&title=&width=198)<br />![image.png](https://cdn.nlark.com/yuque/0/2022/png/390086/1645371661908-c76afa8d-d074-4d6b-ba01-22406965198f.png#clientId=u82040053-338f-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=121&id=u7b2aa325&margin=%5Bobject%20Object%5D&name=image.png&originHeight=121&originWidth=620&originalType=binary&ratio=1&rotation=0&showTitle=false&size=20174&status=done&style=none&taskId=ufbba6faa-bd22-4fd0-9258-7f8e0c1ad64&title=&width=620)<br />主要特点如下：
  3. 1. 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
  4. 1. newFixedThreadPool 创建的线程池 corePoolSize 和 maximumPoolSize 值是相等的，它使用的 LinkedBlockingQueue
  5. <a name="MH104"></a>
  6. ## 9.4.2 newSingleThreadExecutor
  7. ```java
  8. package s02.e09;
  10. import java.util.concurrent.ExecutorService;
  11. import java.util.concurrent.Executors;
  13. public class MyThreadPoolDemo {
  14.     public static void main(String[] args) {
  15.         ExecutorService threadPool = Executors.newSingleThreadExecutor(); // 一池 1 个处理线程。
  16.         try {
  17.             // 模拟 10 个用户来办理业务，每个用户就是一个来自外部的请求线程
  18.             for (int i = 1; i <= 10; i++) {
  19.                 threadPool.execute(() -> {
  20.                     System.out.println(Thread.currentThread().getName() + "\t办理业务");
  21.                 });
  22.             }
  23.         } catch (Exception e) {
  24.             e.printStackTrace();
  25.         } finally {
  26.             threadPool.shutdown();
  27.         }
  28.     }
  29. }

image.png
image.png
主要特点如下：

  1. 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序执行。
  2. newSingleThreadExecutor 将 corePoolSize 和 maximumPoolSize 都设置为 1，它使用的 LinkedBlockingQueue

    9.4.3 newCachedThreadPool

    ```java package s02.e09;

import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors;

public class MyThreadPoolDemo { public static void main(String[] args) { ExecutorService threadPool = Executors.newCachedThreadPool(); // 一池 N 个处理线程。 try { // 模拟 10 个用户来办理业务，每个用户就是一个来自外部的请求线程 for (int i = 1; i <= 10; i++) { threadPool.execute(() -> { System.out.println(Thread.currentThread().getName() + “\t办理业务”); }); } } catch (Exception e) { e.printStackTrace(); } finally { threadPool.shutdown(); } } }

  1. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/390086/1645371458884-8efce448-2c62-4112-be00-5afae923a9b7.png#clientId=u82040053-338f-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=223&id=u302edfbb&margin=%5Bobject%20Object%5D&name=image.png&originHeight=223&originWidth=233&originalType=binary&ratio=1&rotation=0&showTitle=false&size=7507&status=done&style=none&taskId=u05ab0681-a9a1-47f7-a02e-c5607a6701d&title=&width=233)<br />![image.png](https://cdn.nlark.com/yuque/0/2022/png/390086/1645372196652-9e8382fe-399a-4333-9292-d0f04cb3a400.png#clientId=u82040053-338f-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=144&id=u3a3bf4d5&margin=%5Bobject%20Object%5D&name=image.png&originHeight=144&originWidth=564&originalType=binary&ratio=1&rotation=0&showTitle=false&size=20835&status=done&style=none&taskId=u7c77dcfb-214d-4ead-b32e-c868d83a0d1&title=&width=564)<br />主要特点如下：
  3. 1. 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
  4. 1. newCachedThreadPool 将 corePoolSize 设置为 0，将 maximumPoolSize 设置为 Integer.MAX_VALUE，使用的 SynchronousQueue，也就是说来了任务就创建线程运行，当线程空闲超过 60 秒，就销毁线程
  5. <a name="dxAn0"></a>
  6. # 9.5 线程池的几个重要参数介绍
  7. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/390086/1645372788355-6fd4be7e-d2a1-4756-97fb-6fdf1d383e9e.png#clientId=u82040053-338f-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=543&id=ufbd8663d&margin=%5Bobject%20Object%5D&name=image.png&originHeight=543&originWidth=723&originalType=binary&ratio=1&rotation=0&showTitle=false&size=94595&status=done&style=none&taskId=u1a741632-a5e6-4d85-9ac0-0dee0dc940c&title=&width=723)
  9. 1. corePoolSize：线程池中的常驻核心线程数
  10.    1. 在创建了线程池后，当有请求任务来之后，就会安排池中的线程去执行请求任务，近似理解为今日当值线程
  11.    1. 当线程池中的线程数目达到 corePoolSize 后，就会把到达的任务放到缓存队列当中
  12. 2. maximumPoolSize：线程池能够容纳同时执行的最大线程数，此值必须大于等于 1
  13. 2. keepAliveTime：多余的空闲线程的存活时间。<br />当前线程池数量超过 corePoolSize 时，当空闲时间达到 keepAliveTime 值时，多余空闲线程会被销毁直到只剩下 corePoolSize 个线程为止
  14. 2. unit：keepAliveTime 的单位。
  15. 2. workQueue：任务队列，被提交但尚未被执行的任务。
  16. 2. threadFactory：表示生成线程池中工作线程的线程工厂，用于创建线程一般用默认的即可
  17. 2. handler：拒绝策略，表示当队列满了并且工作线程大于等于线程池的最大线程数(maximumPoolSize)时如何来拒绝请求执行的 runnable 的策略
  18. ```java
  19. package s02.e09;
  21. import java.util.concurrent.ExecutorService;
  22. import java.util.concurrent.LinkedBlockingQueue;
  23. import java.util.concurrent.ThreadPoolExecutor;
  24. import java.util.concurrent.TimeUnit;
  26. public class T1 {
  27.     public static void main(String[] args) {
  28.         ExecutorService threadPool = new ThreadPoolExecutor(
  29.                 2, 5, 100L, TimeUnit.SECONDS,
  30.                 new LinkedBlockingQueue<>(3),// 等候区 Executors.defaultThreadFactory(),
  31.                 new ThreadPoolExecutor.AbortPolicy());
  32.         try {
  33.             for (int i = 1; i <= 8; i++) { // 模拟 8 个顾客来办理业务，受理窗口 max 只有 5 个
  34.                 final int tmpI = i;
  35.                 threadPool.execute(() -> {
  36.                     System.out.println(Thread.currentThread().getName() + "号窗口，" + "服务顾客" + tmpI);
  37.                     try {
  38.                         TimeUnit.SECONDS.sleep(4);
  39.                     } catch (InterruptedException e) {
  40.                         e.printStackTrace();
  41.                     }
  42.                 });
  43.             }
  44.         } catch (Exception e) {
  45.             e.printStackTrace();
  46.         } finally {
  47.             threadPool.shutdown();
  48.         }
  49.     }
  50. }

image.png
image.png

9.6 线程池的底层工作原理

image.pngimage.png

  1. 在创建了线程池后，等待提交过来的任务请求。
  2. 当调用 execute() 方法添加一个请求任务时，线程池会做如下判断：
    1. 如果正在运行的线程数量小于 corePoolSize，那么马上创建线程运行这个任务
    2. 如果正在运行的线程数量大于或等于 corePoolSize，那么将这个任务放入队列
    3. 如果这时候队列满了且正在运行的线程数量还小于 maximumPoolSize，那么还是要创建非核心线程立刻运行这个任务
    4. 如果队列满了且正在运行的线程数量大于或等于 maximumPoolSize，那么线程池会启动饱和拒绝策略来执行。
  3. 当一个线程完成任务时，它会从队列中取下一个任务来执行。

  4. 当一个线程无事可做超过一定的时间(keepAliveTime)时，线程池会判断：如果当前运行的线程数大于 corePoolSize，那么这个线程就被停掉。所以线程池的所有任务完成后它最终会收缩到 corePoolSize 的大小。

    9.7 线程池的拒绝策略

    等待队列也已经排满了，再也塞不下新任务了同时，线程池中的 max 线程也达到了，无法继续为新任务服务。这时候我们就需要拒绝策略机制合理的处理这个问题。

  5. AbortPolicy(默认)：直接抛出 RejectedExecutionException 异常阻止系统正常运行。

  6. CallerRunsPolicy：“调用者运行”一种调节机制，该策略既不会抛弃任务，也不会抛出异常，而是将某些任务回退到调用者，从而降低新任务的流量。
  7. DiscardOldestPolicy：抛弃队列中等待最久的任务，然后把当前任务加入队列中尝试再次提交当前任务
  8. DiscardPolicy：直接丢弃任务，不予任何处理也不抛出异常。如果允许任务丢失，这是最好的一种方案。

以上内置拒绝策略均实现了 RejectedExecutionHandler 接口

9.8 工作中创建线程池的方法

问：工作中单一的/固定数的/可变的三种创建线程池的方法，你用那个多？
答：一个都不用，我们生产上只能使用自定义的
问：Executors 中 JDK 已经给你提供了，为什么不用？
image.png

  1. package s02.e09;
  3. import java.util.concurrent.*;
  5. public class MyThreadPoolDemo {
  6.     public static void main(String[] args) {
  7.         ExecutorService threadPool = new ThreadPoolExecutor(
  8.                 2,
  9.                 5,
  10.                 1L,
  11.                 TimeUnit.SECONDS,
  12.                 new LinkedBlockingQueue<Runnable>(3),
  13.                 Executors.defaultThreadFactory(),
  14.                 new ThreadPoolExecutor.AbortPolicy()
  15.         );
  16.         try {
  17.             // 模拟 10 个用户来办理业务，每个用户就是一个来自外部的请求线程
  18.             for (int i = 1; i <= 8; i++) {
  19.                 threadPool.execute(() -> {
  20.                     System.out.println(Thread.currentThread().getName() + "\t办理业务");
  21.                 });
  22.             }
  23.         } catch (Exception e) {
  24.             e.printStackTrace();
  25.         } finally {
  26.             threadPool.shutdown();
  27.         }
  28.     }
  29. }

image.png
最大只能处理 8 个 用户，最大数为 maximumPoolSize + workQueue

  1. package s02.e09;
  3. import java.util.concurrent.*;
  5. public class MyThreadPoolDemo {
  6.     public static void main(String[] args) {
  7.         ExecutorService threadPool = new ThreadPoolExecutor(
  8.                 2,
  9.                 5,
  10.                 1L,
  11.                 TimeUnit.SECONDS,
  12.                 new LinkedBlockingQueue<Runnable>(3),
  13.                 Executors.defaultThreadFactory(),
  14.                 new ThreadPoolExecutor.AbortPolicy()
  15.         );
  16.         try {
  17.             // 模拟 10 个用户来办理业务，每个用户就是一个来自外部的请求线程
  18.             for (int i = 1; i <= 9; i++) {
  19.                 threadPool.execute(() -> {
  20.                     System.out.println(Thread.currentThread().getName() + "\t办理业务");
  21.                 });
  22.             }
  23.         } catch (Exception e) {
  24.             e.printStackTrace();
  25.         } finally {
  26.             threadPool.shutdown();
  27.         }
  28.     }
  29. }

image.png

  1. package s02.e09;
  3. import java.util.concurrent.*;
  5. public class MyThreadPoolDemo {
  6.     public static void main(String[] args) {
  7.         ExecutorService threadPool = new ThreadPoolExecutor(
  8.                 2,
  9.                 5,
  10.                 1L,
  11.                 TimeUnit.SECONDS,
  12.                 new LinkedBlockingQueue<Runnable>(3),
  13.                 Executors.defaultThreadFactory(),
  14.                 new ThreadPoolExecutor.CallerRunsPolicy()
  15.         );
  16.         try {
  17.             // 模拟 10 个用户来办理业务，每个用户就是一个来自外部的请求线程
  18.             for (int i = 1; i <= 10; i++) {
  19.                 threadPool.execute(() -> {
  20.                     System.out.println(Thread.currentThread().getName() + "\t办理业务");
  21.                 });
  22.             }
  23.         } catch (Exception e) {
  24.             e.printStackTrace();
  25.         } finally {
  26.             threadPool.shutdown();
  27.         }
  28.     }
  29. }

image.png

  1. package s02.e09;
  3. import java.util.concurrent.*;
  5. public class MyThreadPoolDemo {
  6.     public static void main(String[] args) {
  7.         ExecutorService threadPool = new ThreadPoolExecutor(
  8.                 2,
  9.                 5,
  10.                 1L,
  11.                 TimeUnit.SECONDS,
  12.                 new LinkedBlockingQueue<Runnable>(3),
  13.                 Executors.defaultThreadFactory(),
  14.                 new ThreadPoolExecutor.DiscardOldestPolicy()
  15.         );
  16.         try {
  17.             // 模拟 10 个用户来办理业务，每个用户就是一个来自外部的请求线程
  18.             for (int i = 1; i <= 10; i++) {
  19.                 threadPool.execute(() -> {
  20.                     System.out.println(Thread.currentThread().getName() + "\t办理业务");
  21.                 });
  22.             }
  23.         } catch (Exception e) {
  24.             e.printStackTrace();
  25.         } finally {
  26.             threadPool.shutdown();
  27.         }
  28.     }
  29. }

image.png

  1. package s02.e09;
  3. import java.util.concurrent.*;
  5. public class MyThreadPoolDemo {
  6.     public static void main(String[] args) {
  7.         ExecutorService threadPool = new ThreadPoolExecutor(
  8.                 2,
  9.                 5,
  10.                 1L,
  11.                 TimeUnit.SECONDS,
  12.                 new LinkedBlockingQueue<Runnable>(3),
  13.                 Executors.defaultThreadFactory(),
  14.                 new ThreadPoolExecutor.DiscardPolicy()
  15.         );
  16.         try {
  17.             // 模拟 10 个用户来办理业务，每个用户就是一个来自外部的请求线程
  18.             for (int i = 1; i <= 10; i++) {
  19.                 threadPool.execute(() -> {
  20.                     System.out.println(Thread.currentThread().getName() + "\t办理业务");
  21.                 });
  22.             }
  23.         } catch (Exception e) {
  24.             e.printStackTrace();
  25.         } finally {
  26.             threadPool.shutdown();
  27.         }
  28.     }
  29. }

image.png

9.9 线程池配置合理线程数

9.9.1 CPU 密集型

CPU 密集的意思是该任务需要大量的运算，而没有阻塞，CPU 一直全速运行。CPU 密集任务只有在真正的多核 CPU 上才可能得到加速(通过多线程)，而在单核CPU上，无论你开几个模拟的多线程该任务都不可能得到加速，因为 CPU 总的运算能力就那些。CPU 密集型任务配置尽可能少的线程数量。
一般公式：CPU 核数 + 1个线程的线程池

9.9.2 IO 密集型

方案一：由于 IO 密集型任务线程并不是一直在执行任务，则应配置尽可能多的线程，如 CPU 核数 * 2
方案二：IO密集型，即该任务需要大量的 IO，即大量的阻塞。在单线程上运行 IO 密集型的任务会导致浪费大量的 CPU 运算能力浪费在等待。所以在 IO 密集型任务中使用多线程可以大大的加速程序运行，即使在单核 CPU 上，这种加速主要就是利用了被浪费掉的阻塞时间。IO 密集型时，大部分线程都阻塞，故需要多配置线程数
参考公式：CPU 核数 / (1 – 阻塞系数)
阻塞系数在 0.8~0.9 之间
比如 8 核 CPU：8 / (1 - 0.9) = 80 个线程数