Java线程池--种类--Executors--使用/用法/实例/示例/实战

曾经终败给现在 2022-08-28 11:50 137阅读 0赞

原文网址：[Java线程池--种类--Executors--使用/用法/实例/示例/实战\_IT利刃出鞘的博客-CSDN博客][Java_--_--Executors--_IT_-CSDN]

# 简介 #

**说明**

线程池是Java多线程常用的技术，本文介绍线程池的种类，以及使用。

**常见线程池种类**

<table> 
 <tbody> 
 <tr> 
 <td> 种类 </td> 
 <td> 核心线程数 </td> 
 <td> 最大线程数 </td> 
 <td> 描述 </td> 
 </tr> 
 <tr> 
 <td>固定大小(fixed)</td> 
 <td> n </td> 
 <td> n（虽然有但实际不起作用） </td> 
 <td> </td> 
 </tr> 
 <tr> 
 <td>单个(single)</td> 
 <td> 1 </td> 
 <td> 1 </td> 
 <td> 只一个线程在工作，相当于单线程顺序串行执行所有任务。 </td> 
 </tr> 
 <tr> 
 <td>定时(scheduled)</td> 
 <td> n </td> 
 <td> 无限大 </td> 
 <td> 周期性执行任务 </td> 
 </tr> 
 <tr> 
 <td>缓存(cached)</td> 
 <td> 0 </td> 
 <td> 无限大 </td> 
 <td> 动态增删线程数 </td> 
 </tr> 
 </tbody> 
</table>

**创建的方法**

<table> 
 <tbody> 
 <tr> 
 <td> 方法 </td> 
 <td> 作用 </td> 
 <td> 说明 </td> 
 <td> ThreadPoolExecutor参数 </td> 
 </tr> 
 <tr> 
 <td> newFixed ThreadPool </td> 
 <td> 创建固定大小的线程池。 </td> 
 <td> 提交一个任务创建一个线程，直到最大数。&nbsp; 线程池数一旦达到最大值就会保持不变。 若某线程因异常而结束，会有新线程替代。 </td> 
 <td> nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue&lt;Runnable&gt;() //nThreads是传进来的参数 </td> 
 </tr> 
 <tr> 
 <td> newSingle ThreadExecutor </td> 
 <td> 创建一个单线程的线程池。 </td> 
 <td> 只一个线程工作，相当于单线程串行执行。 若此线程因异常而结束，会有新线程替代。 保证任务的执行顺序按任务提交顺序执行。 </td> 
 <td> 1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue&lt;Runnable&gt;() </td> 
 </tr> 
 <tr> 
 <td> newScheduled ThreadPool </td> 
 <td> 创建一个固定大小的定时线程池。 </td> 
 <td> 支持定时以及周期性执行任务的需求。 </td> 
 <td> corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS, new DelayedWorkQueue() //corePoolSize是传进来的参数 </td> 
 </tr> 
 <tr> 
 <td> newSingleThread ScheduledExecutor </td> 
 <td> 创建一个单线程的定时线程池。 </td> 
 <td> 支持定时以及周期性执行任务的需求。 </td> 
 <td> return new DelegatedScheduledExecutorService (newScheduledThreadPoolExecutor(1)); </td> 
 </tr> 
 <tr> 
 <td> newCached ThreadPool </td> 
 <td> 创建一个可缓存的线程池。 </td> 
 <td> &nbsp; &nbsp; 若线程池的数量超过了处理任务所需要的线程，就回收部分空闲（默认60秒不执行任务）的线程。 &nbsp; &nbsp; 当任务数增加时，此线程池又可以智能的添加新线程来处理任务。 </td> 
 <td> 0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue&lt;Runnable&gt;() </td> 
 </tr> 
 </tbody> 
</table>

这些方法的返回值是ExecutorService对象，该对象表示一个线程池，可以执行Runnable对象或者Callable对象代表的线程。

# 固定大小(fixed) #

## 简介 ##

**execute流程**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70][]

对上图的说明如下。

1.  如果当前运行的线程数少于corePoolSize，则创建一个新线程来执行任务。
2.  在线程池完成线程的创建之后，将任务加入Linked- BlockingQueue。
3.  线程会在一个无限循环中反复从LinkedBlockingQueue获取任务来执行。

固定大小的线程池使用**无界队列**LinkedBlockingQueue作为线程池的工作队列（**队列的容量为 Integer.MAX\_VALUE**）。使用无界队列作为工作队列会对线程池带来如下影响：

1.  线程池中的线程数达到corePoolSize后，新任务将在无界队列中等待，因此线程池中的线程数不会超过corePoolSize。
2.  由于1，使用无界队列时maximumPoolSize将是一个无效参数。
3.  由于1和2，使用无界队列时keepAliveTime将是一个无效参数。
4.  由于使用无界队列，运行中的FixedThreadPool（未执行方法shutdown()或 shutdownNow()）不会拒绝任务（不会调用RejectedExecutionHandler.rejectedExecution方法）。

## 实例 ##

**代码**

package org.example.a;
 
 import java.util.concurrent.*;
 
 class MyTask implements Runnable {
 private int taskNum;
 
 public MyTask(int num) {
 this.taskNum = num;
 }
 
 @Override
 public void run() {
 System.out.println(Thread.currentThread().getName() + " " + "正在执行task "+taskNum);
 try {
 Thread.currentThread().sleep(1000);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 System.out.println(Thread.currentThread().getName() + " " + "--执行task "+taskNum + " 完毕!!!");
 }
 }
 
 public class Demo {
 public static void main(String[] args) {
 ExecutorService executor = Executors.newFixedThreadPool(3);
 
 for(int i=0;i<6;i++){
 MyTask myTask = new MyTask(i);
 executor.execute(myTask);
 }
 executor.shutdown();
 }
 }

**执行结果**

pool-1-thread-2 正在执行task 1
    pool-1-thread-3 正在执行task 2
    pool-1-thread-1 正在执行task 0
    pool-1-thread-3 --执行task 2 完毕!!!
    pool-1-thread-3 正在执行task 3
    pool-1-thread-2 --执行task 1 完毕!!!
    pool-1-thread-2 正在执行task 4
    pool-1-thread-1 --执行task 0 完毕!!!
    pool-1-thread-1 正在执行task 5
    pool-1-thread-1 --执行task 5 完毕!!!
    pool-1-thread-3 --执行task 3 完毕!!!
    pool-1-thread-2 --执行task 4 完毕!!!

# **单个(single)** #

## **简介** ##

**execute流程**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 1][]

对上图的说明如下。

1.  如果当前运行的线程数少于corePoolSize，则创建一个新线程来执行任务。
2.  在线程池完线程的创建之后，将任务加入Linked- BlockingQueue。
3.  线程会在一个无限循环中反复从LinkedBlockingQueue获取任务来执行。

## 实例 ##

**代码**

package org.example.a;
 
 import java.util.concurrent.*;
 
 class MyTask implements Runnable {
 private int taskNum;
 
 public MyTask(int num) {
 this.taskNum = num;
 }
 
 @Override
 public void run() {
 System.out.println(Thread.currentThread().getName() + " " + "正在执行task "+taskNum);
 try {
 Thread.currentThread().sleep(1000);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 System.out.println(Thread.currentThread().getName() + " " + "--执行task "+taskNum + " 完毕!!!");
 }
 }
 
 public class Demo {
 public static void main(String[] args) {
 ExecutorService executor = Executors.newSingleThreadExecutor();
 
 for(int i=0;i<6;i++){
 MyTask myTask = new MyTask(i);
 executor.execute(myTask);
 }
 executor.shutdown();
 }
 }

**执行结果**

pool-1-thread-1 正在执行task 0
    pool-1-thread-1 --执行task 0 完毕!!!
    pool-1-thread-1 正在执行task 1
    pool-1-thread-1 --执行task 1 完毕!!!
    pool-1-thread-1 正在执行task 2
    pool-1-thread-1 --执行task 2 完毕!!!
    pool-1-thread-1 正在执行task 3
    pool-1-thread-1 --执行task 3 完毕!!!
    pool-1-thread-1 正在执行task 4
    pool-1-thread-1 --执行task 4 完毕!!!
    pool-1-thread-1 正在执行task 5
    pool-1-thread-1 --执行task 5 完毕!!!

# 定时(scheduled) #

**其他网址**

《Java并发编程之美》=> 第9章 Java 并发包中ScheduledThreadPoolExecutor 原理探究

## 简介 ##

**创建**

1.  ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
2.  ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(1);
    
    1.  此法获得的对象为ScheduledThreadPoolExecutor，它实现了ScheduledExecutorService，继承了ThreadPoolExecutor。所以，它比法1多了ThreadPoolExecutor的一些方法，例如：
        
        1.  public boolean remove(Runnable task)
        2.  public void purge()
        3.  public int getActiveCount()

**方法**

<table> 
 <tbody> 
 <tr> 
 <td> 方法 </td> 
 <td> 描述 </td> 
 </tr> 
 <tr> 
 <td> schedule(Callable&lt;V&gt; callable, long delay, TimeUnit unit) </td> 
 <td> 创建任务：在给定延迟后只执行一次。 </td> 
 </tr> 
 <tr> 
 <td> schedule(Runnable command, long delay, TimeUnit unit) </td> 
 <td>创建任务：在给定延迟后只执行一次。</td> 
 </tr> 
 <tr> 
 <td> scheduleAtFixedRate(Runnable command, long initialDelay,long period, TimeUnitunit) </td> 
 <td> 创建任务：固定周期执行。在 initialDelay 后开始执行，然后在initialDelay+period 后执行，接着在 initialDelay + 2 * period 后执行，依此类推。 </td> 
 </tr> 
 <tr> 
 <td> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay,TimeUnit unit) </td> 
 <td> 创建任务：上个任务执行完后，固定周期执行。在 initialDelay 后开始执行，运行完后，延时period 后执行，执行完后，再延时&nbsp;period 后执行，依此类推。 </td> 
 </tr> 
 </tbody> 
</table>

**ScheduledThreadPoolExecutor与Timer对比**

<table> 
 <tbody> 
 <tr> 
 <td>项</td> 
 <td>Timer</td> 
 <td>ScheduledThreadPoolExecutor</td> 
 </tr> 
 <tr> 
 <td> 线程数量 </td> 
 <td> 单线程。 单线程执行所有TimerTask，若某TimerTask任务执行时间比较久，会影响其他任务的调度执行。 </td> 
 <td> 多线程。 重用线程池，某个ScheduledFutureTask任务执行的时间比较久，不会影响到其他任务的调度执行。 </td> 
 </tr> 
 <tr> 
 <td> 系统时间敏感度 </td> 
 <td> 对操作系统的时间敏感。 基于操作系统的绝对时间，若操作系统的时间改变，则Timer的调度不再精确。 </td> 
 <td> 不受操作系统时间改变的影响。 基于相对时间的，不受操作系统时间改变的影响。 </td> 
 </tr> 
 <tr> 
 <td> 是否捕获异常 </td> 
 <td> 不捕获TimerTask抛出的异常。 加上Timer又是单线程的。一旦某个调度任务出现异常，则整个线程就终止，其他需要调度的任务也不再执行。 </td> 
 <td> 不捕获异常。 基于线程池来实现调度功能，某个任务抛出异常后，其他任务仍能正常执行。 </td> 
 </tr> 
 <tr> 
 <td> 任务是否具备优先级 </td> 
 <td> 没有优先级。 只是按照系统的绝对时间来执行任务。 </td> 
 <td> 有优先级。 ScheduledFutureTask类实现了java.lang.Comparable接口和java.util.concurrent.Delayed接口。Comparable#compareTo方法实现了任务的比较，距离下次执行的时间间隔短的任务会排在前面。而Delayed#getDelay方法：能够返回距离下次任务执行的时间间隔。 </td> 
 </tr> 
 <tr> 
 <td> 是否支持对任务排序 </td> 
 <td>不支持对任务的排序。</td> 
 <td> 支持。 ScheduledThreadPoolExecutor类中定义了一个静态内部类DelayedWorkQueue，它是一个有序队列，为需要调度的每个任务按照距离下次执行时间间隔的大小来排序 </td> 
 </tr> 
 <tr> 
 <td> 能否获取返回的结果 </td> 
 <td> 不能。 TimerTask类只是实现了java.lang.Runnable接口，无法从TimerTask中获取返回的结果。 </td> 
 <td> 能。 ScheduledFutureTask类继承了FutureTask类，能够通过Future来获取返回的结果。 </td> 
 </tr> 
 </tbody> 
</table>

## **实例(单定时)** ##

**示例1：（间隔时间（3s）大于任务的执行时间（1s））**

package org.example.a;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.concurrent.*;
    
    class MyTask implements Runnable {
        @Override
        public void run() {
            try {
                SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
                System.out.println(sdf.format(new Date()) + " " + "正在执行task");
                Thread.currentThread().sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("--执行task " + " 完毕!!!");
        }
    }
    
    public class Demo {
            ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
            executor.scheduleAtFixedRate(new MyTask(), 0, 3, TimeUnit.SECONDS);
            // executor.scheduleWithFixedRate(new MyTask(), 0, 3, TimeUnit.SECONDS);
            //不能加这句
            //executor.shutdown();
        }
    }

> **运行结果**
> 
> scheduleAtFixedRate：可见，每3秒运行一次
> 
>     22:54:15 正在执行task
>     --执行task  完毕!!!
>     22:54:18 正在执行task
>     --执行task  完毕!!!
>     22:54:21 正在执行task
>     --执行task  完毕!!!
>     22:54:24 正在执行task
>     --执行task  完毕!!!
>     22:54:27 正在执行task
>     --执行task  完毕!!!
>     22:54:30 正在执行task
>     --执行task  完毕!!!
>     22:54:33 正在执行task
>     --执行task  完毕!!!
> 
> scheduleWithFixedRate：可见，每4秒运行一次
> 
>     23:04:08 正在执行task
>     --执行task  完毕!!!
>     23:04:12 正在执行task
>     --执行task  完毕!!!
>     23:04:16 正在执行task
>     --执行task  完毕!!!
>     23:04:20 正在执行task
>     --执行task  完毕!!!
>     23:04:24 正在执行task
>     --执行task  完毕!!!
>     23:04:28 正在执行task

**示例2 ：（间隔时间（3s）小于任务的执行时间（4s））**

>     package org.example.a;
>     
>     import java.text.SimpleDateFormat;
>     import java.util.Date;
>     import java.util.concurrent.*;
>     
>     class MyTask implements Runnable {
>         @Override
>         public void run() {
>             try {
>                 SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
>                 System.out.println(sdf.format(new Date()) + " " + "正在执行task");
>                 Thread.currentThread().sleep(4000);
>             } catch (InterruptedException e) {
>                 e.printStackTrace();
>             }
>             System.out.println("--执行task " + " 完毕!!!");
>         }
>     }
>     
>     public class Demo {
>         public static void main(String[] args) {
>             ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
>             executor.scheduleAtFixedDelay(new MyTask(), 0, 3, TimeUnit.SECONDS);
>             //executor.scheduleWithFixedDelay(new MyTask(), 0, 3, TimeUnit.SECONDS);
>             //这句不要写
>             //executor.shutdown();
>         }
>     }

**运行结果**

> scheduleAtFixedRate：可见，此时间隔时间失效，会以任务执行时间为准。上一个任务一结束就开始下一个任务
> 
>     22:58:53 正在执行task
>     --执行task  完毕!!!
>     22:58:57 正在执行task
>     --执行task  完毕!!!
>     22:59:01 正在执行task
>     --执行task  完毕!!!
>     22:59:05 正在执行task
>     --执行task  完毕!!!
>     22:59:09 正在执行task
>     --执行task  完毕!!!

> scheduleWithFixedRate：
> 
>     23:08:31 正在执行task
>     --执行task  完毕!!!
>     23:08:38 正在执行task
>     --执行task  完毕!!!
>     23:08:45 正在执行task
>     --执行task  完毕!!!
>     23:08:52 正在执行task
>     --执行task  完毕!!!
>     23:08:59 正在执行task
>     --执行task  完毕!!!

## 异常处理 ##

若程序中捕获了异常，则不影响下一个任务执行，若不捕获，则会影响下一个任务执行。

**示例1：不捕获异常**

>     package org.example.a;
>     
>     import java.text.SimpleDateFormat;
>     import java.util.Date;
>     import java.util.concurrent.*;
>     
>     class MyTask implements Runnable {
>         int i = 0;
>         int[] a = {1, 2, 3};
>         @Override
>         public void run() {
>             SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
>             System.out.println(sdf.format(new Date()) + " " + "正在执行task");
>             System.out.println(a[i++]);
>             System.out.println("-------------------执行task " + " 完毕!!!");
>         }
>     }
>     
>     public class Demo {
>         public static void main(String[] args) {
>             ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
>             executor.scheduleWithFixedDelay(new MyTask(), 0, 1, TimeUnit.SECONDS);
>             //这句不要写
>             //executor.shutdown();
>         }
>     }

运行结果（异常后，直接卡死）

23:15:28 正在执行task
    1
    -------------------执行task  完毕!!!
    23:15:29 正在执行task
    2
    -------------------执行task  完毕!!!
    23:15:30 正在执行task
    3
    -------------------执行task  完毕!!!
    23:15:31 正在执行task

**示例2：捕获异常**

package org.example.a;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.concurrent.*;
    
    class MyTask implements Runnable {
        int i = 0;
        int[] a = {1, 2, 3};
        @Override
        public void run() {
            try {
                SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
                System.out.println(sdf.format(new Date()) + " " + "正在执行task");
                System.out.println(a[i++]);
                System.out.println("-------------------执行task " + " 完毕!!!");
            } catch (Exception e) {
                e.printStackTrace();
            }
    
        }
    }
    
    public class Demo {
        public static void main(String[] args) {
            ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
            executor.scheduleWithFixedDelay(new MyTask(), 0, 1, TimeUnit.SECONDS);
            //这句不要写
            //executor.shutdown();
        }
    }

执行结果（一直往下执行）

23:17:10 正在执行task
    1
    -------------------执行task  完毕!!!
    23:17:11 正在执行task
    2
    -------------------执行task  完毕!!!
    23:17:12 正在执行task
    3
    -------------------执行task  完毕!!!
    23:17:13 正在执行task
    java.lang.ArrayIndexOutOfBoundsException: 3
    	at org.example.a.MyTask.run(Demo.java:15)
    	at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)
    	at java.util.concurrent.FutureTask.runAndReset(FutureTask.java:308)
    	at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.access$301(ScheduledThreadPoolExecutor.java:180)
    	at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.java:294)
    	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
    	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
    	at java.lang.Thread.run(Thread.java:745)
    23:17:14 正在执行task
    java.lang.ArrayIndexOutOfBoundsException: 4
    	at org.example.a.MyTask.run(Demo.java:15)
    	at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)
    	at java.util.concurrent.FutureTask.runAndReset(FutureTask.java:308)
    	at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.access$301(ScheduledThreadPoolExecutor.java:180)
    	at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.java:294)
    	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
    	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
    	at java.lang.Thread.run(Thread.java:745)
    23:17:15 正在执行task
    java.lang.ArrayIndexOutOfBoundsException: 5
    	at org.example.a.MyTask.run(Demo.java:15)
    	at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)
    	at java.util.concurrent.FutureTask.runAndReset(FutureTask.java:308)
    	at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.access$301(ScheduledThreadPoolExecutor.java:180)
    	at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.java:294)
    	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
    	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
    	at java.lang.Thread.run(Thread.java:745)

# **缓存(cached)** #

## **简介** ##

**CachedThreadPool的execute流程**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 2][]

对上图的说明如下。

首先执行SynchronousQueue.offer(Runnable task)。如果当前maximumPool中有空闲线程正在执行  
SynchronousQueue.poll(keepAliveTime，TimeUnit.NANOSECONDS)，那么主线程执行offer操作与空闲线程执行的poll操作配对成功，主线程把任务交给空闲线程执行，execute()方法执行完成；否则执行下面的步骤

当初始maximumPool为空，或者maximumPool中当前没有空闲线程时，将没有线程执行  
SynchronousQueue.poll(keepAliveTime，TimeUnit.NANOSECONDS)。这种情况下，步骤（1）将失败。此时CachedThreadPool会创建一个新线程执行任务，execute()方法执行完成。

在步骤（2）中新创建的线程将任务执行完后，会执行 SynchronousQueue.poll(keepAliveTime，TimeUnit.NANOSECONDS)。这个poll操作会让空闲线程最多在SynchronousQueue中等待60秒钟。如果60秒钟内主线程提交了一个新任务（主线程执行步骤（1）），那么这个空闲线程将执行主线程提交的新任务；否则，这个空闲线程将终止。由于空闲60秒的空闲线程会被终止，因此长时间保持空闲的CachedThreadPool不会使用任何资源。

前面提到过，SynchronousQueue是一个没有容量的阻塞队列。每个插入操作必须等待另一个线程的对应移除操作，反之亦然。CachedThreadPool使用SynchronousQueue，把主线程提交的任务传递给空闲线程执行。CachedThreadPool中任务传递的示意图如图所示。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 3][]

CachedThreadPool是一个会根据需要创建新线程的线程池。下面是创建CachedThreadPool的源代码。

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

CachedThreadPool的corePoolSize被设置为0，即corePool为空；maximumPoolSize被设置为 Integer.MAX\_VALUE，即maximumPool是无界的。这里把keepAliveTime设置为60L，意味着 CachedThreadPool中的空闲线程等待新任务的最长时间为60秒，空闲线程超过60秒后将会被终止。

FixedThreadPool和SingleThreadExecutor使用无界队列LinkedBlockingQueue作为线程池的工作队列。CachedThreadPool使用没有容量的SynchronousQueue作为线程池的工作队列，但 CachedThreadPool的maximumPool是无界的。这意味着，如果主线程提交任务的速度高于 maximumPool中线程处理任务的速度时，CachedThreadPool会不断创建新线程。**极端情况下， CachedThreadPool会因为创建过多线程而耗尽CPU和内存资源**。

[Java_--_--Executors--_IT_-CSDN]: https://knife.blog.csdn.net/article/details/120518082
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70]: /images/20220828/1d5d1b6093dd4fff8980e55fcfc47664.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 1]: /images/20220828/ec2b0a882e704acd9fcc2855bda79def.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 2]: /images/20220828/443e12badbaf4bf5907c4b9b717ca448.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 3]: /images/20220828/8a48c43fbc2a476e824268b53786939d.png