线程的4种创建方式及区别

末蓝、 2023-03-05 06:29 12阅读 0赞

# 四种基本实现方式 #

1、继承Thread类  
2、实现Runnable接口  
3、实现Callable接口  
4、创建线程池

实现Runnable和实现Callable接口的方式基本相同，不过前者线程执行体run()方法无返回值，而后者执行call()方法有返回值，因此可以把这两种方式归为一种这种方式与继承Thread类的方法之间的差别如下：

1、线程只是实现Runnable或实现Callable接口，还可以继承其他类。

2、这种方式下，多个线程可以共享一个target对象，非常适合多线程处理同一份资源的情形。

3、但是编程稍微复杂，如果需要访问当前线程，必须调用Thread.currentThread()方法。

4、继承Thread类的线程类不能再继承其他父类（Java单继承决定）。

5、前三种的线程如果创建关闭频繁会消耗系统资源影响性能，而使用线程池可以不用线程的时候放回线程池，用的时候再从线程池取，项目开发中主要使用线程池

注：在前三种中一般推荐采用实现接口的方式来创建多线程

## 一、extends Thread类 ##

通过继承Thread类来创建并启动多线程的一般步骤如下

1】定义Thread类的子类，并重写该类的run()方法，该方法的方法体就是线程需要完成的任务，run()方法也称为线程执行体。

2】创建Thread子类的实例，也就是创建了线程对象

3】启动线程，即调用线程的start()方法

package com.example.worktest.async.thread.callable.service;
    
    import org.springframework.stereotype.Service;
    
    @Service
    public class ThreadTest extends Thread{ 
    
        @Override
        public void run(){ 
            System.out.println("继承Thread类的线程");
        }
    }

@GetMapping("/test1")
        public String threadTest() { 
            ThreadTest threadTest = new ThreadTest();
            threadTest.start();
            return Thread.currentThread().getName();
        }

运行后的执行结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODQ0Njg5MQ_size_16_color_FFFFFF_t_70]

## 二、实现Runnable接口 ##

通过实现Runnable接口创建并启动线程一般步骤如下：

1】定义Runnable接口的实现类，重写run()方法，这个run（）方法和Thread中的run()方法一样是线程的执行体

2】创建Runnable实现类的实例，并用这个实例作为Thread的target来创建Thread对象，这个Thread对象才是真正的线程对象

3】通过调用线程对象的start()方法来启动线程

package com.example.worktest.async.thread.callable.service;
    
    import org.springframework.stereotype.Service;
    
    @Service
    public class RunTest implements Runnable{ 
    
        public void  run(){ 
            System.out.println("runnable___"+Thread.currentThread().getName());
        }
    }

@GetMapping("/test2")
        public String runnableTest() { 
            RunTest runTest = new RunTest();
            Thread thread = new Thread(runTest);
            Thread thread1 = new Thread(runTest,"自己命名的runnable线程yyyy");
            thread.start();
            thread1.start();
            return Thread.currentThread().getName();
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODQ0Njg5MQ_size_16_color_FFFFFF_t_70 1]

## 三、实现Callable接口 ##

### 3.1 Callable和Runnable接口的不同点 ###

1】Runnable接口是run()方法，Callable接口提供了一个call（）方法作为线程执行体，call()方法比run()方法功能要强大。

2】call()方法可以有返回值

3】call()方法可以声明抛出异常

4】Callable能接受一个泛型，然后在call方法中返回一个这个类型的值。而Runnable的run方法没有返回值（下面以String为例）

### 3.2 实现步骤 ###

1】创建Callable接口的实现类，并实现call()方法，然后创建该实现类的实例（从java8开始可以直接使用Lambda表达式创建Callable对象）。

2】创建一个 FutureTask ，它将在运行时执行给定的 Callable ，该FutureTask对象封装了Callable对象的call()方法的返回值

3】使用FutureTask对象作为Thread对象的target创建并启动线程（因为FutureTask实现了Runnable接口）

4】调用FutureTask/**Future（线程池时使用）** 对象的get()方法来获得子线程执行结束后的返回值  
**<< get方法建议与isDone方法同用！！不然get方法在线程执行完之前会一直阻塞！！>>**

@Component
    public class CallTest implements Callable<String>{ 
    
        @Override
        public String call() throws Exception{ 
            return "这是callable的call方法";
        }
    }

@GetMapping("/test3")
        public void callableTest(){ 
            try{ 
                CallTest callTest = new CallTest();
                FutureTask<String> futureTask = new FutureTask<String>(callTest);
                Thread thread3 = new Thread(futureTask);
                thread3.start();
                while (true){ 
                    if(futureTask.isDone()){ 
                        System.out.println(futureTask.get());
                        break;
                    }
                    Thread.sleep(2000);
                    System.out.println("线程还未执行完，sleep2000ms后再尝试");
                }
    
            }catch (Exception e) { 
                e.printStackTrace();
            }
        }

执行结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODQ0Njg5MQ_size_16_color_FFFFFF_t_70 2]

### 3.3 FutureTask ###

线程Thread的构造方法：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODQ0Njg5MQ_size_16_color_FFFFFF_t_70 3]

三个构造器：无参构造器、一个参数构造器和两个参数构造器。但是就没有我们Callable作为参数的构造器。那么，我们想要获取到线程，通过callable怎么获取呢 ？  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODQ0Njg5MQ_size_16_color_FFFFFF_t_70 4]  
我们先来看一下FutureTask的实现：

public class FutureTask<V> implements RunnableFuture<V>

FutureTask类实现了RunnableFuture接口，我们看一下RunnableFuture接口的实现：

public interface RunnableFuture<V> extends Runnable, Future<V> { 
        void run();
    }

可以看出RunnableFuture继承了Runnable接口和Future接口，而FutureTask实现了RunnableFuture接口。所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。  
FutureTask提供了2个构造器：

> public FutureTask(Callable callable) \{ \}  
> public FutureTask(Runnable runnable, V result) \{ \}

事实上，FutureTask是Future接口的一个唯一实现类。

## 四、线程池 ##

### 4.0 线程池的好处 ###

在一个应用程序中，我们需要多次使用线程，也就意味着，我们需要多次创建并销毁线程。而**创建并销毁线程的过程势必会消耗内存**。而在Java中，内存资源是及其宝贵的，所以，我们就提出了线程池的概念。

线程池：Java中开辟出了一种管理线程的概念，这个概念叫做线程池，从概念以及应用场景中，我们可以看出，线程池的好处，就是可以方便的管理线程，也可以减少内存的消耗。

> 减少资源的开销  
> 减少了每次创建线程、销毁线程的开销。  
> 提高响应速度 ,每次请求到来时，由于线程的创建已经完成，故可以直接执行任务，因此提高了响应速度。  
> 提高线程的可管理性 ,线程是一种稀缺资源，若不加以限制，不仅会占用大量资源，而且会影响系统的稳定性。 因此，线程池可以对线程的创建与停止、线程数量等等因素加以控制，使得线程在一种可控的范围内运行，不仅能保证系统稳定运行，而且方便性能调优。

那么，我们应该如何创建一个线程池那?Java中已经提供了创建线程池的一个类：Executor

而我们创建时，一般使用它的子类：**ThreadPoolExecutor**

### 4.1 线程池不要使用Executors构造！！！ ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODQ0Njg5MQ_size_16_color_FFFFFF_t_70 5]  
Executors 大大的简化了我们创建各种类型线程池的方式，为什么还不让使用呢？  
其实，只要你打开看看它的静态方法参数就会明白了  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODQ0Njg5MQ_size_16_color_FFFFFF_t_70 6]  
传入的workQueue 是一个边界为 Integer.MAX\_VALUE 队列，我们也可以变相的称之为无界队列了，因为边界太大了，这么大的等待队列也是非常消耗内存的

/** * Creates a {@code LinkedBlockingQueue} with a capacity of * {@link Integer#MAX_VALUE}. */
    public LinkedBlockingQueue() { 
      this(Integer.MAX_VALUE);
    }

另外该 ThreadPoolExecutor方法使用的是默认拒绝策略（直接拒绝），但并不是所有业务场景都适合使用这个策略，当很重要的请求过来直接选择拒绝显然是不合适的  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODQ0Njg5MQ_size_16_color_FFFFFF_t_70 7]  
总的来说，使用 Executors 创建的线程池太过于理想化，并不能满足很多现实中的业务场景，所以要求我们通过 ThreadPoolExecutor来创建，并传入合适的参数

阿里巴巴Java开发手册，明确指出不允许使用Executors静态工厂构建线程池  
原因如下：  
线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险

综上：**Executors返回的线程池对象的弊端如下：**

1：FixedThreadPool 和 SingleThreadPool：  
允许的请求队列（底层实现是LinkedBlockingQueue）长度为Integer.MAX\_VALUE，可能会堆积大量的请求，从而导致OOM  
2：CachedThreadPool 和 ScheduledThreadPool  
允许的创建线程数量为Integer.MAX\_VALUE，可能会创建大量的线程，从而导致OOM。

### 4.2 线程池的创建方式 ###

Java 也提供了它自己实现的线程池模型—— **ThreadPoolExecutor**。套用上面池化的想象来说，Java线程池就是为了最大化高并发带来的性能提升，并最小化手动创建线程的风险，将多个线程统一在一起管理的思想

public ThreadPoolExecutor(int corePoolSize,
                                  int maximumPoolSize,
                                  long keepAliveTime,
                                  TimeUnit unit,
                                  BlockingQueue<Runnable> workQueue,
                                  ThreadFactory threadFactory,
                                  RejectedExecutionHandler handler) { 
            if (corePoolSize < 0 ||
                maximumPoolSize <= 0 ||
                maximumPoolSize < corePoolSize ||
                keepAliveTime < 0)
                throw new IllegalArgumentException();
            if (workQueue == null || threadFactory == null || handler == null)
                throw new NullPointerException();
            this.acc = System.getSecurityManager() == null ?
                    null :
                    AccessController.getContext();
            this.corePoolSize = corePoolSize;
            this.maximumPoolSize = maximumPoolSize;
            this.workQueue = workQueue;
            this.keepAliveTime = unit.toNanos(keepAliveTime);
            this.threadFactory = threadFactory;
            this.handler = handler;
    }

所有线程池最终都是通过这个方法来创建的。

**corePoolSize** : 核心线程数，一旦创建将不会再释放。如果创建的线程数还没有达到指定的核心线程数量，将会继续创建新的核心线程，直到达到最大核心线程数后，核心线程数将不在增加；如果没有空闲的核心线程，同时又未达到最大线程数，则将继续创建非核心线程；如果核心线程数等于最大线程数，则当核心线程都处于激活状态时，任务将被挂起，等待空闲线程来执行。

**maximumPoolSize** : 最大线程数，允许创建的最大线程数量。如果最大线程数等于核心线程数，则无法创建非核心线程；如果非核心线程处于空闲时，超过设置的空闲时间，则将被回收，释放占用的资源。

**keepAliveTime** : 也就是当线程空闲时，所允许保存的最大时间，超过这个时间，线程将被释放销毁，但只针对于非核心线程。

**unit** : 时间单位，TimeUnit.SECONDS等。

**workQueue**：工作队列，保存未执行的Runnable 任务

**threadFactory**：创建线程的工厂类

**handler**：当线程已满，工作队列也满了的时候，会被调用。被用来实现各种拒绝策略。

eg：

private ExecutorService pool = new ThreadPoolExecutor(3, 10,
                10L, TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(512), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

代码：

@GetMapping("/test4")
        public void threadPoolTest(){ 
            try{ 
                //创建线程池
                ExecutorService executorService = new ThreadPoolExecutor(3, 10,
                        50, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
                //创建
                Callable myCallable = new Callable() { 
                    @Override
                    public String call() throws Exception { 
                        Thread.sleep(3000);
                        System.out.println("call方法执行了");
                        return "call方法返回值";
                    }
                };
                Future future = executorService.submit(myCallable);
                while (true){ 
                    if(future.isDone()){ 
                        System.out.println(future.get());
                        break;
                    }
                    Thread.sleep(2000);
                    System.out.println("线程池内的线程还没执行完方法，sleep2000ms");
                }
            }catch (Exception e) { 
                e.printStackTrace();
            }
        }

### 4.3 ExecutorService 、ThreadPoolExecutor及常用方法 ###

Java里面线程池的顶级接口是Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是ExecutorService。

比较重要的几个类：

**ExecutorService**： 真正的线程池接口。

**ScheduledExecutorService**： 能和Timer/TimerTask类似，解决那些需要任务重复执行的问题。

**ThreadPoolExecutor**： ExecutorService的默认实现。

**ScheduledThreadPoolExecutor**： 继承ThreadPoolExecutor的ScheduledExecutorService接口实现，周期性任务调度的类实现。

ThreadPoolExecutor是ExecutorService的实现类  
Java.util.concurrent.ThreadPoolExecutor类是ExecutorSerivce接口的具体实现。ThreadPoolExecutor使用线程池中的一个线程来执行给定的任务（Runnable或者Callable）。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODQ0Njg5MQ_size_16_color_FFFFFF_t_70 8]

#### Executor框架中的所有类可以分成三类： ####

1.  任务  
    任务有两种类型：Runnable和Callable。
2.  任务执行器  
    Executor框架最核心的接口是Executor，它表示任务的执行器。  
    Executor的子接口为ExecutorService。  
    ExecutorService有两大实现类：ThreadPoolExecutor和ScheduledThreadPoolExecutor。
3.  执行结果  
    Future接口表示异步的执行结果，它的实现类为FutureTask。

#### ExcutorService的使用说明 ####

下面是委托任务给ExecutorService的一些不同的方式：

**execute(Runnable)  
submit(Runnable)  
submit(Callable)**  
关闭线程池有两种方式：**shutdown和shutdownNow**，关闭时，会遍历所有的线程，调用它们的interrupt函数中断线程。但这两种方式对于正在执行的线程处理方式不同。

**shutdown()**  
仅停止阻塞队列中等待的线程，那些正在执行的线程就会让他们执行结束。  
**shutdownNow()**  
不仅会停止阻塞队列中的线程，而且会停止正在执行的线程。

其中

public void execute(Runnable command) { 
            if (command == null)
                throw new NullPointerException();
      
            int c = ctl.get();
            if (workerCountOf(c) < corePoolSize) { 
                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);
                else if (workerCountOf(recheck) == 0)
                    addWorker(null, false);
            }
            else if (!addWorker(command, false))
                reject(command);
        }

public <T> Future<T> submit(Callable<T> task) { 
            if (task == null) throw new NullPointerException();
            RunnableFuture<T> ftask = newTaskFor(task);
            execute(ftask);
            return ftask;
        }

**execute(Runnable)**  
execute(Runnable) 方法接受一个java.lang.Runable对象的实例，并异步执行之，**这种方式不能获得Runnable执行的结果**。下面是一个使用ExecutorService执行Runnable的例子：

public void threadPoolTest(){ 
            try{ 
                ThreadPoolExecutor executorService = new ThreadPoolExecutor(3, 10,
                        50, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
                //创建一个Runnable
                Runnable runnable = new Runnable() { 
                    @Override
                    public void run() { 
                        System.out.println("run方法执行了");
                    }
                };
    
                executorService.execute(runnable);
            }catch (Exception e) { 
                e.printStackTrace();
            }
        }
    --------------------------------执行结果------------------------------------------------
    run方法执行了

**submit的方法**

public Future<?> submit(Runnable task) { 
            if (task == null) throw new NullPointerException();
            RunnableFuture<Void> ftask = newTaskFor(task, null);
            execute(ftask);
            return ftask;
        }
    
        /**
         * @throws RejectedExecutionException { @inheritDoc}
         * @throws NullPointerException       { @inheritDoc}
         */
        public <T> Future<T> submit(Runnable task, T result) { 
            if (task == null) throw new NullPointerException();
            RunnableFuture<T> ftask = newTaskFor(task, result);
            execute(ftask);
            return ftask;
        }
    
        /**
         * @throws RejectedExecutionException { @inheritDoc}
         * @throws NullPointerException       { @inheritDoc}
         */
        public <T> Future<T> submit(Callable<T> task) { 
            if (task == null) throw new NullPointerException();
            RunnableFuture<T> ftask = newTaskFor(task);
            execute(ftask);
            return ftask;
        }

**submit(Runnable)**  
submit(Runnable) 方法也接收一个Runnable接口的具体实现，并返回一个Future对象。Future对象可以用来检测Runable是否执行完成。  
返回的Future对象是null

public void threadPoolTest(){ 
            try{ 
                ThreadPoolExecutor executorService = new ThreadPoolExecutor(3, 10,
                        50, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
                //创建一个Runnable
                Runnable runnable = new Runnable() { 
                    @Override
                    public void run() { 
                        System.out.println("run方法执行了");
                    }
                };
    
                Future future = executorService.submit(runnable);
                while (true){ 
                    if(future.isDone()){ 
                        System.out.println(future.get());
                        break;
                    }
                    Thread.sleep(2000);
                    System.out.println("线程池内的线程还没执行完方法，sleep2000ms");
                }
            }catch (Exception e) { 
                e.printStackTrace();
            }
        }
    ---------------------------------执行结果----------------------------------------------
    run方法执行了
    线程池内的线程还没执行完方法，sleep2000ms
    null

**submit(Callable)**  
submit(Callable)方法与submit(Runnable)方法相似，除了接收的参数有所不同。Callable实例非常类似于Runnable,不同的是call方法可以返回一个结果，Runnable.run()方法不能返回一个结果。

可以通过submit(Callable)方法返回的Future对象获取Callable的结果。下面是一个使用Callable的例子：

public void threadPoolTest(){ 
            try{ 
                ThreadPoolExecutor executorService = new ThreadPoolExecutor(3, 10,
                        50, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
                //创建一个Callable
                Callable callable = new Callable() { 
                    @Override
                    public String call() throws Exception { 
                        Thread.sleep(3000);
                        System.out.println("call方法执行了");
                        return "call方法返回值";
                    }
                };
                Future future = executorService.submit(callable);
                while (true){ 
                    if(future.isDone()){ 
                        System.out.println(future.get());
                        break;
                    }
                    Thread.sleep(2000);
                    System.out.println("线程池内的线程还没执行完方法，sleep2000ms");
                }
            }catch (Exception e) { 
                e.printStackTrace();
            }
        }
    ---------------------------------执行结果----------------------------------------- 
    线程池内的线程还没执行完方法，sleep2000ms
    call方法执行了
    线程池内的线程还没执行完方法，sleep2000ms
    call方法返回值

### submit和execute方法区别 ###

**1、 接收的参数不一样**  
submit接收的Callable、Runnable对象，但返回一个future，execute只接收Runnable对象

**2、submit有返回值，而execute没有**  
用到返回值的例子，比如说我有很多个做validation的task，我希望所有的task执行完，然后每个task告诉我它的执行结果，是成功还是失败，如果是失败，原因是什么。  
然后我就可以把所有失败的原因综合起来发给调用者。  
个人觉得cancel execution这个用处不大，很少有需要去取消执行的。

**3、submit方便Exception处理（ ）**  
意思就是如果你在你的task里会抛出checked或者unchecked exception，  
而你又希望外面的调用者能够感知这些exception并做出及时的处理，那么就需要用到submit，通过捕获Future.get()抛出的异常。  
比如说，我有很多更新各种数据的task，我希望如果其中一个task失败，其它的task就不需要执行了。那我就需要catch Future.get抛出的异常，然后终止其它task的执行。

使用结论：https://blog.csdn.net/hayre/article/details/53314599

> 结论一：如果提交的任务不需要一个结果的话直接用execute()会提升很多性能。  
> 结论二：就是相当于说如果你传的任务是需要结果的，那你就使用你的类去继承Callable接口，然后告诉submit方法就行了，如果你只需要一个特定的结果，就把那个特定的结果告诉submit方法然后把你想要的特定结果也告诉他，它只是帮你完成以前使用Future模式的时候你自己需要做的那些步骤而已，如果你不需要一个结果，那么就老老实实使用execute，如果你需要的是一个空结果，那么submit(yourRunnable)与submit(yourRunnable,null)是等价的！

### 4.4 线程池的工作原理 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODQ0Njg5MQ_size_16_color_FFFFFF_t_70 9]  
有图我们可以看出，任务进来时，首先执行判断，判断核心线程是否处于空闲状态，如果不是，核心线程就先就执行任务，如果核心线程已满，则判断任务队列是否有地方存放该任务，若果有，就将任务保存在任务队列中，等待执行，如果满了，在判断最大可容纳的线程数，如果没有超出这个数量，就开创非核心线程执行任务，如果超出了，就调用handler实现拒绝策略。

handler的拒绝策略：

有四种：

> **AbortPolicy**:(线程池默认策略) 不执行新任务，直接抛出异常，提示线程池已满。切记ThreadPoolExecutor.execute需要try catch，否则程序会直接退出。  
> **DisCardPolicy**:不执行新任务，也不抛出异常。直接抛弃，任务不执行，空方法  
> **DisCardOldSetPolicy:** 从阻塞队列里的头元素出队抛弃，并再尝试提交任务  
> **CallerRunsPolicy:** 为调节机制，既不抛弃任务也不抛出异常，而是将某些任务退回到调用者。即，不会在线程池的线程中执行新的任务，而是在调用exector的线程中运行新的任务。

### 4.5 线程池的种类 ###

`CachedThreadPool` : **可缓存的线程池**，该线程池中没有核心线程，非核心线程的数量为Integer.max\_value，就是无限大，当有需要时创建线程来执行任务，没有需要时回收线程，适用于耗时少，任务量大的情况。  
创建一个可缓存的线程池。先查看池中有没有以前建立的线程，如果有，就再 reuse，如果没有，就建一个新的线程加入池中。这种类型的线程池特点是：  
a、工作线程的创建数量几乎没有限制(其实也有限制的,数目为Interger. MAX\_VALUE), 这样可灵活的往线程池中添加线程。  
b、如果长时间没有往线程池中提交任务，即如果工作线程空闲了指定的时间(默认为1分钟)，则该工作线程将自动终止。终止后，如果你又提交了新的任务，则线程池重新创建一个工作线程。

`ScheduleThreadPool` : **周期性执行任务的线程池**，按照某种特定的计划执行线程中的任务，有核心线程，但也有非核心线程，非核心线程的大小也为无限大。适用于执行周期性的任务。  
（1）核心线程数固定，非核心线程（闲着没活干会被立即回收）数没有限制。  
（2）ScheduledThreadPool主要用于执行定时任务以及有固定周期的重复任务。

`SingleThreadPool` : **只有一条线程来执行任务**，适用于有顺序的任务的应用场景。

`FixedThreadPool`: **定长的线程池**，只有核心线程，核心线程的即为最大的线程数量，没有非核心线程。创建一个指定工作线程数量的线程池。每当提交一个任务就创建一个工作线程，如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列中。

### 4.6 线程池的终止 ###

**void shutdown()：** 不会立即终止线程池，首先将线程池的状态设置成STOP，然后尝试停止所有的正在执行或暂停任务的线程。此时，则不能再往线程池中添加任何新的任务，否则将会抛出RejectedExecutionException异常。但是，此时线程池不会立刻退出，直到添加到线程池中的任务都已经处理完成，才会退出。

**List shutdownNow()：** 将线程池的状态设置成SHUTDOWN状态， 立即终止线程池，并且尝试打断正在运行的线程，清空缓存队列中的任务，返回尚未开始的任务。

只要调用了这两个关闭方法中的任意一个，isShutdown方法就会返回true。当所有的任务都已关闭后，才表示线程池关闭成功，这时调用isTerminaed方法会返回true。至于应该调用哪一种方法来关闭线程池，应该由提交到线程池的任务特性决定，通常调用shutdown方法来关闭线程池，如果任务不一定要执行完，则可以调用shutdownNow方法。

**使用场景：**  
场景一：所有线程都是一个task，都是批处理作业，相互之间没有什么关系，某个线程的异常对结果影响不大。那么所有线程都能在执行任务结束之后可以正常结束，程序能在所有task都做完之后正常退出，适合用ShutDown。

场景二：所有线程都是一个工人，源源不断的从任务池中接收任务，整个任务周期非常长。但是，如果一个线程在做某个任务的时候失败，则整个结果就是失败的，其他worker再继续做剩下的任务也是徒劳，这就需要让他们全部停止当前的工作。这里使用ShutDownNow就可以让该pool中的所有线程都停止当前的工作，从而迫使所有线程执行退出。从而让主程序正常退出。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODQ0Njg5MQ_size_16_color_FFFFFF_t_70]: /images/20230208/ec5187e1b88f4587b6d1b829a039ec73.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODQ0Njg5MQ_size_16_color_FFFFFF_t_70 1]: /images/20230208/6cce5ead03154bb5b81f6392e6fabfb3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODQ0Njg5MQ_size_16_color_FFFFFF_t_70 2]: /images/20230208/9e41f185bde842ba8937fbf42685dbc1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODQ0Njg5MQ_size_16_color_FFFFFF_t_70 3]: /images/20230208/d5400c747a194c8ca5fda5731b70c192.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODQ0Njg5MQ_size_16_color_FFFFFF_t_70 4]: /images/20230208/9c6416fda89b4e39b8e959c0f69d3310.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODQ0Njg5MQ_size_16_color_FFFFFF_t_70 5]: /images/20230208/bd0e7d53baea440c9efe4c7d902b37b6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODQ0Njg5MQ_size_16_color_FFFFFF_t_70 6]: /images/20230208/934a999224494ea8911acaea08e9c0ed.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODQ0Njg5MQ_size_16_color_FFFFFF_t_70 7]: /images/20230208/7783343871dc48078bac20088a921bf8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODQ0Njg5MQ_size_16_color_FFFFFF_t_70 8]: /images/20230208/7c2a162794cf4064807747abdbc09879.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODQ0Njg5MQ_size_16_color_FFFFFF_t_70 9]: /images/20230208/31e1b7bfd5744f9da3dff26cd99ed0a6.png