深入理解高并发编程 - 线程池与初谈 ThreadPoolExecutor 类

浅浅的花香味﹌ 2023-10-14 15:33 46阅读 0赞

## 1、Thread 直接创建线程的弊端 ##

在 Java 中，创建线程的主要方法是通过实例化 Thread 类并调用其 start() 方法来启动一个新线程。然而，直接创建线程（即通过创建 Thread 的实例）也存在一些弊端和问题：

资源消耗：每个线程都需要一定的系统资源，包括内存、线程栈和线程管理等。直接创建线程可能会导致创建过多的线程，从而消耗大量的系统资源，可能会影响系统的稳定性和性能。
    
    线程管理复杂性：直接创建线程会导致线程的管理变得复杂。需要自己处理线程的生命周期、并发控制、线程间通信等问题，这可能会引入并发 bug 和难以维护的代码。
    
    可伸缩性问题：在某些情况下，直接创建线程可能会导致应用程序的可伸缩性受限。因为线程的数量有限，当线程数量增多时，线程之间的竞争可能会增加，从而导致性能下降。
    
    不利于线程池管理：使用线程池来管理线程是一种更可控且资源友好的方式。直接创建线程会使得线程的生命周期和资源管理不太适合线程池的管理模式。
    
    可移植性问题：线程的创建和管理可能在不同的操作系统上有所不同。直接创建线程可能会导致代码在不同平台上表现不一致。

## 2、线程池 ##

### 2.1、线程池的好处 ###

线程池是一种管理和复用线程的机制，它带来了许多好处，特别是在多线程应用程序中。以下是线程池的一些主要好处：

资源管理：线程池可以管理和限制系统中的线程数量，避免过多地创建和销毁线程。这有助于减少系统资源的消耗，特别是内存和处理器资源。
    
    性能提升：通过复用线程，避免了线程创建和销毁的开销，从而减少了系统开销，提高了应用程序的性能和响应性。
    
    并发控制：线程池可以控制并发任务的数量，避免过多的线程同时执行，从而防止系统资源耗尽和性能下降。
    
    任务队列：线程池通常配备一个任务队列，用于存储待执行的任务。这确保了任务按照一定的顺序执行，避免了任务堆积和资源浪费。
    
    线程复用：线程池中的线程可以被复用，减少了线程创建和销毁的开销，提高了线程利用率。
    
    可控性：线程池提供了一些参数和配置选项，可以根据应用程序的需求进行调整，从而更好地控制线程池的行为。
    
    线程生命周期管理：线程池负责管理线程的生命周期，包括创建、销毁和异常处理。这减轻了开发人员对线程生命周期的管理责任。
    
    灵活性：线程池允许在需要时灵活地提交任务，而无需手动管理线程的创建和销毁，从而简化了代码结构。
    
    避免过多的线程：在高并发场景下，直接创建大量线程可能会导致系统资源耗尽或性能下降。线程池可以限制线程数量，避免这种问题。

总之，线程池是一种有效的多线程管理机制，它在提高性能、资源管理、并发控制和代码可维护性等方面都带来了显著的好处。在多数情况下，使用线程池比直接创建线程更合适。

### 2.2、线程池的类结构关系 ###

在 Java 中，线程池的类结构关系主要涉及到以下几个关键类和接口：

#### Executor 接口： ####

Executor 接口定义了一个执行任务的简单协议，它只包含一个方法 execute(Runnable command)，用于提交一个任务给执行器。

package com.lfsun.main.basic.myjuc.depthstudy.threadpool;
    
    import java.util.concurrent.Executor;
    
    public class SimpleExecutor implements Executor {
    
        @Override
        public void execute(Runnable command) {
            // 在当前线程中执行任务
            command.run();
        }
    
        public static void main(String[] args) {
            // 创建自定义的 Executor 实例
            Executor executor = new SimpleExecutor();
    
            // 提交任务给执行器
            executor.execute(new Task("Task 1"));
            executor.execute(new Task("Task 2"));
        }
    
        // 示例任务类
        static class Task implements Runnable {
            private final String name;
    
            public Task(String name) {
                this.name = name;
            }
    
            @Override
            public void run() {
                System.out.println("Executing task: " + name);
            }
        }
    }

#### ExecutorService 接口： ####

ExecutorService 继承自 Executor 接口，扩展了任务提交和管理的功能。它提供了一些方法，如 submit() 用于提交任务、shutdown() 用于关闭线程池等。

package com.lfsun.main.basic.myjuc.depthstudy.threadpool;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class ExecutorServiceExample {
    
        public static void main(String[] args) {
            // 创建固定大小的线程池
            ExecutorService executorService = Executors.newFixedThreadPool(2);
    
            // 提交任务给线程池
            executorService.submit(new Task("Task 1"));
            executorService.submit(new Task("Task 2"));
    
            // 关闭线程池
            executorService.shutdown();
        }
    
        // 示例任务类
        static class Task implements Runnable {
            private final String name;
    
            public Task(String name) {
                this.name = name;
            }
    
            @Override
            public void run() {
                System.out.println("Executing task: " + name);
            }
        }
    }

#### AbstractExecutorService 类： ####

AbstractExecutorService 是一个抽象类，实现了 ExecutorService 接口的部分方法，提供了一些默认的实现。它可以用作自定义线程池的基类。

package com.lfsun.main.basic.myjuc.depthstudy.threadpool;
    
    import java.util.List;
    import java.util.concurrent.AbstractExecutorService;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.TimeUnit;
    
    public class CustomThreadPoolExample {
    
        public static void main(String[] args) {
            ExecutorService executorService = new MyThreadPool();
            
            executorService.submit(new Task("Task 1"));
            executorService.submit(new Task("Task 2"));
            
            executorService.shutdown();
        }
    
        static class MyThreadPool extends AbstractExecutorService {
    
            private ExecutorService delegate = Executors.newFixedThreadPool(2);
    
            @Override
            public void execute(Runnable command) {
                delegate.execute(command);
            }
    
            @Override
            public void shutdown() {
                delegate.shutdown();
            }
    
            @Override
            public List<Runnable> shutdownNow() {
                return delegate.shutdownNow();
            }
    
            @Override
            public boolean isShutdown() {
                return delegate.isShutdown();
            }
    
            @Override
            public boolean isTerminated() {
                return delegate.isTerminated();
            }
    
            @Override
            public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
                return delegate.awaitTermination(timeout, unit);
            }
        }
    
        static class Task implements Runnable {
            private final String name;
    
            public Task(String name) {
                this.name = name;
            }
    
            @Override
            public void run() {
                System.out.println("Executing task: " + name);
            }
        }
    }

#### ThreadPoolExecutor 类： ####

ThreadPoolExecutor 是 Java 中最常用的线程池实现类。它继承自 AbstractExecutorService，并提供了一个灵活的线程池实现，可以自定义线程池的核心线程数、最大线程数、任务队列、拒绝策略等。

package com.lfsun.main.basic.myjuc.depthstudy.threadpool;
    
    import java.util.concurrent.*;
    
    public class ThreadPoolExecutorExample {
    
        public static void main(String[] args) {
            int corePoolSize = 2;
            int maxPoolSize = 4;
            long keepAliveTime = 60L;
            TimeUnit timeUnit = TimeUnit.SECONDS;
            BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>();
            RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();
    
            ThreadPoolExecutor executor = new ThreadPoolExecutor(
                    corePoolSize, maxPoolSize, keepAliveTime, timeUnit, workQueue, handler);
    
            executor.execute(new Task("Task 1"));
            executor.execute(new Task("Task 2"));
            executor.execute(new Task("Task 3"));
            executor.execute(new Task("Task 4"));
            
            executor.shutdown();
        }
    
        static class Task implements Runnable {
            private final String name;
    
            public Task(String name) {
                this.name = name;
            }
    
            @Override
            public void run() {
                System.out.println("Executing task: " + name + " in thread: " + Thread.currentThread().getName());
            }
        }
    }

#### ScheduledExecutorService 接口： ####

ScheduledExecutorService 扩展了 ExecutorService，添加了支持定时任务调度的能力，它提供了一些方法用于在一定的延迟后或定时执行任务。

package com.lfsun.main.basic.myjuc.depthstudy.threadpool;
    
    import java.util.concurrent.*;
    
    public class ScheduledExecutorServiceExample {
    
        public static void main(String[] args) throws InterruptedException {
            ScheduledExecutorService executor = Executors.newScheduledThreadPool(2);
    
            // 延迟 2 秒执行任务
            executor.schedule(new Task("Delayed Task"), 2, TimeUnit.SECONDS);
    
            // 延迟 1 秒后开始执行，然后每隔 3 秒执行一次
            executor.scheduleAtFixedRate(new Task("Fixed Rate Task"), 1, 3, TimeUnit.SECONDS);
    
            // 延迟 1 秒后开始执行，然后在上一次任务结束后等待 2 秒再执行下一次
            executor.scheduleWithFixedDelay(new Task("Fixed Delay Task"), 1, 2, TimeUnit.SECONDS);
    
            Thread.sleep(10000);
            // 关闭线程池
            executor.shutdown();
        }
    
        static class Task implements Runnable {
            private final String name;
    
            public Task(String name) {
                this.name = name;
            }
    
            @Override
            public void run() {
                System.out.println("Executing task: " + name + " in thread: " + Thread.currentThread().getName());
            }
        }
    }

#### ScheduledThreadPoolExecutor 类： ####

ScheduledThreadPoolExecutor 是实现了 ScheduledExecutorService 接口的类，它继承自 ThreadPoolExecutor，允许创建一个支持定时任务调度的线程池。

package com.lfsun.main.basic.myjuc.depthstudy.threadpool;
    
    import java.util.concurrent.*;
    
    public class ScheduledThreadPoolExecutorExample {
    
        public static void main(String[] args) throws InterruptedException {
            ScheduledExecutorService executor = new ScheduledThreadPoolExecutor(2);
    
            // 延迟 2 秒执行任务
            executor.schedule(new Task("Delayed Task"), 2, TimeUnit.SECONDS);
    
            // 延迟 1 秒后开始执行，然后每隔 3 秒执行一次
            executor.scheduleAtFixedRate(new Task("Fixed Rate Task"), 1, 3, TimeUnit.SECONDS);
    
            // 延迟 1 秒后开始执行，然后在上一次任务结束后等待 2 秒再执行下一次
            executor.scheduleWithFixedDelay(new Task("Fixed Delay Task"), 1, 2, TimeUnit.SECONDS);
    
            Thread.sleep(10000);
            // 关闭线程池
            executor.shutdown();
        }
    
        static class Task implements Runnable {
            private final String name;
    
            public Task(String name) {
                this.name = name;
            }
    
            @Override
            public void run() {
                System.out.println("Executing task: " + name + " in thread: " + Thread.currentThread().getName());
            }
        }
    }

### 2.3、创建线程池常用的类——Executors ###

java.util.concurrent.Executors 是 Java 并发库中提供的一个工具类，用于创建不同类型的线程池。它提供了一些静态方法，使得线程池的创建和管理更加简单和方便。以下是一些常用的方法：

newFixedThreadPool(int nThreads)：创建一个固定大小的线程池，线程数量始终保持不变。当有新任务提交时，如果线程池中的线程都在执行任务，新任务会被放入队列等待。
    
    newCachedThreadPool()：创建一个可以根据需要自动扩展和收缩的线程池。适用于执行大量短期任务的情况。
    
    newSingleThreadExecutor()：创建一个只有一个线程的线程池。适用于需要保证任务按顺序执行的情况。
    
    newScheduledThreadPool(int corePoolSize)：创建一个定时任务调度线程池，可以执行定时和周期性任务。
    
    newSingleThreadScheduledExecutor()：创建一个只有一个线程的定时任务调度线程池。

这些方法返回的线程池实例都实现了 ExecutorService 接口，可以使用 submit() 方法提交任务。同时，通过 Executors 类提供的方法，也可以传递自定义的线程工厂、任务队列和拒绝策略来定制线程池的行为。

虽然 Executors 提供了一些方便的方法来创建线程池，但在实际应用中，根据具体需求，可能需要更加精细地配置线程池，以避免出现资源耗尽、任务堆积等问题。特别是在高并发和大量任务的情况下，最好根据应用程序的特点来选择合适的线程池配置。

### 2.4、线程池实例的几种状态 ###

在 Java 中，线程池实例可以处于不同的状态，这些状态反映了线程池的运行状态和生命周期。以下是线程池实例可能的几种状态：

RUNNING（运行中）：线程池已经启动并处于正常运行状态。在这个状态下，线程池可以接受新的任务，并且会按照配置的参数执行任务。
    
    SHUTDOWN（关闭中）：线程池正在关闭过程中，不再接受新的任务提交。但是，它会继续执行已经提交的任务，直到所有任务都完成。
    
    STOP（停止）：线程池已经停止，不再接受新的任务提交，也不再执行已提交的任务。正在执行的任务会被中断。
    
    TIDYING（整理中）：线程池正在整理状态，即正在执行清理操作，释放资源等。
    
    TERMINATED（终止）：线程池已经完全终止，所有任务都已经完成，线程池的状态不可再变更。

线程池状态的变化通常会伴随着线程池生命周期的不同阶段，例如线程池的创建、启动、提交任务、关闭和终止等。通过使用线程池提供的方法，可以控制线程池的状态变化，以便适应不同的应用需求。不需要对线程池的状态做特殊的处理，线程池的状态是线程池内部根据方法自行定义和处理的。

### 2.5、合理配置线程的一些建议 ###

不同的应用场景和需求可能需要不同的线程池配置。

**1.选择合适的线程池类型：**

如果需要执行大量的短期任务，可以考虑使用 `Executors.newCachedThreadPool()。`  
如果需要执行固定数量的任务，可以使用 `Executors.newFixedThreadPool(int nThreads)。`  
如果需要执行定时任务，可以使用 `Executors.newScheduledThreadPool(int corePoolSize)。`

**2.根据硬件配置优化线程数：**  
***CPU 密集型任务：***

CPU 密集型任务是指任务的主要操作是 CPU 计算，而不是等待外部资源。在这种情况下，要最大限度地利用 CPU，可以考虑将线程数设置为 CPU 核心数加 1，即 NCPU + 1。额外的一个线程可以用于保持 CPU 忙碌，提高任务执行效率。  
***IO 密集型任务：***

IO 密集型任务是指任务主要涉及等待 I/O 操作，例如文件读写、网络请求等。在这种情况下，线程往往会在等待 I/O 操作的时候处于空闲状态，所以可以适当增加线程数以提高并发度。根据经验，可以将线程数设置为 CPU 核心数的两倍，即 2 \* NCPU，以充分利用等待时间。

**3.设置合适的任务队列大小：**  
任务队列用于存储等待执行的任务。根据任务的特性和负载情况，选择合适的任务队列类型和大小，以避免任务堆积和资源浪费。

*无界队列（Unbounded Queue）：*  
无界队列不限制队列的大小，任务可以一直添加到队列中，直到内存耗尽。适用于任务数较多且执行时间较短的场景，可以防止任务因为队列满而被拒绝。  
但是要注意，如果任务提交速度大于执行速度，可能会导致内存占用过高，甚至导致系统崩溃。

*有界队列（Bounded Queue）：*  
有界队列限制了队列的最大大小，当队列满时，新的任务将被拒绝。  
适用于控制任务数量和避免资源耗尽的场景。有界队列的大小需要根据负载情况和系统资源进行合理设置，以避免任务堆积。

*优先级队列（Priority Queue）：*  
优先级队列根据任务的优先级来决定执行顺序。适用于希望优先处理某些重要任务的场景。

*延迟队列（Delay Queue）：*  
延迟队列中的任务只有在指定的延迟时间之后才能被取出执行。适用于需要延迟执行任务的场景，如定时任务调度。

*同步队列（Synchronous Queue）：*  
同步队列在任务被提交后，必须立即有线程进行处理，否则提交会被阻塞。适用于需要严格控制任务提交和执行的场景。

**4.考虑使用拒绝策略：**  
当线程池无法接受新任务时，拒绝策略定义了如何处理这些被拒绝的任务。根据应用需求，选择合适的拒绝策略，如 `ThreadPoolExecutor.AbortPolicy、ThreadPoolExecutor.CallerRunsPolicy` 等。

*ThreadPoolExecutor.AbortPolicy（默认策略）：*

当线程池无法接受新任务时，会抛出 `RejectedExecutionException` 异常，表示拒绝执行任务。如果不希望丢失任务并且希望在任务被拒绝时立即得到通知，可以使用此策略。  
**注意**：在任务量过大或线程池饱和的情况下，可能会导致大量任务被拒绝并且异常堆积。

*ThreadPoolExecutor.DiscardPolicy：*

当线程池无法接受新任务时，被拒绝的任务将被默默地丢弃，不会抛出异常，也不会通知。  
如果任务被丢弃不会影响系统稳定性，可以使用此策略。

*ThreadPoolExecutor.DiscardOldestPolicy：*

当线程池无法接受新任务时，将尝试将最早的等待任务从队列中移除，然后尝试重新提交新任务。适用于希望保留较新任务并且可以丢弃一些等待时间较长的任务的场景。

*ThreadPoolExecutor.CallerRunsPolicy：*

当线程池无法接受新任务时，由提交任务的线程（调用 execute 方法的线程）执行被拒绝的任务。可以用于控制任务的提交速率，防止任务堆积，但可能会影响原线程的执行性能。

*自定义拒绝策略：*

如果内置的拒绝策略无法满足特定需求，可以实现自定义的 `RejectedExecutionHandler` 接口，来定义如何处理被拒绝的任务。

**5.使用合适的等待时间和超时机制：**  
当等待线程池中的任务完成时，可以使用 awaitTermination() 方法设置合适的等待时间和超时机制，以确保任务的完成。

try {
                // 等待线程池中的任务完成，最多等待 5 秒
                if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
                    // 超时后可以选择强制关闭线程池
                    executor.shutdownNow();
                }
            } catch (InterruptedException e) {
                // 处理中断异常
                e.printStackTrace();
            }

**6.使用合适的线程工厂：**  
线程工厂用于创建线程实例，可以通过自定义线程工厂来设置线程的命名规则、优先级等。

package com.lfsun.main.basic.myjuc.depthstudy.threadpool;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.ThreadFactory;
    import java.util.concurrent.atomic.AtomicInteger;
    
    public class CustomThreadFactoryExample {
    
        public static void main(String[] args) {
            ThreadFactory threadFactory = new CustomThreadFactory();
    
            ExecutorService executor = Executors.newFixedThreadPool(2, threadFactory);
    
            executor.submit(new Task("Task 1"));
            executor.submit(new Task("Task 2"));
    
            executor.shutdown();
        }
    
        static class CustomThreadFactory implements ThreadFactory {
            private final AtomicInteger threadCount = new AtomicInteger(1);
    
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r);
                thread.setName("CustomThread-" + threadCount.getAndIncrement());
                thread.setPriority(Thread.NORM_PRIORITY);
                return thread;
            }
        }
    
        static class Task implements Runnable {
            private final String name;
    
            public Task(String name) {
                this.name = name;
            }
    
            @Override
            public void run() {
                System.out.println("Executing task: " + name + " in thread: " + Thread.currentThread().getName());
            }
        }
    }

**7.监控和调优：**  
使用监控工具和性能分析来监视线程池的性能和资源使用情况，根据实际情况进行调优。

**8.避免滥用线程池：**  
并不是所有情况都需要使用线程池。在一些场景中，使用单个线程或其他并发机制可能更合适。

简单的异步操作：如果只需要执行少量简单的异步操作，直接创建一个新线程或使用 Java 的异步机制（如 CompletableFuture）可能更加简单和直观。
    
    定时任务：对于一些简单的定时任务，可以使用 java.util.Timer 或 ScheduledExecutorService 来执行定时操作，而无需创建复杂的线程池。
    
    GUI 应用程序：在图形用户界面（GUI）应用程序中，通常使用事件分发线程（Event Dispatch Thread，EDT）来处理用户界面的事件，而不是使用线程池。
    
    资源受限的环境：在资源受限的环境中，如移动设备或嵌入式系统，可能需要更加谨慎地管理线程，避免过多的线程资源消耗。
    
    特定的并发模型：在某些并发模型中，可能会使用其他的并发机制，如管道（Pipes and Filters）、消息传递等，来更好地满足需求。
    
    对线程状态和生命周期有特殊要求：如果需要更精细地控制线程的状态和生命周期，可能需要直接管理线程而不使用线程池。
    
    避免过度复杂化：有时候引入线程池可能会增加代码复杂性，而在某些简单场景下，直接管理线程可能更加简单明了。

**9.合理处理异常：**  
在任务执行过程中可能会抛出异常，确保线程池能够正确地处理异常情况，避免线程被异常终止。

确保线程池能够正确地处理任务执行过程中的异常情况是保障应用程序稳定性的重要一步。如果线程池中的线程因为未捕获的异常而终止，可能会导致线程池无法继续正常工作。以下是一些方法来处理线程池中的异常情况：

*捕获异常：*  
在任务的 run() 方法中，使用 try-catch 块捕获可能抛出的异常。确保异常在任务内部得到处理，不会被传播到线程池的外部。

*处理异常：*  
根据异常的类型和业务逻辑，可以在捕获异常后采取适当的处理措施，如记录日志、回滚事务等。确保异常不会影响其他任务的执行。

*自定义异常处理器：*  
如果想要在任务出现异常时采取统一的处理措施，可以实现自定义的 `Thread.UncaughtExceptionHandler` 接口，用于处理未捕获的异常。

class CustomExceptionHandler implements Thread.UncaughtExceptionHandler {
        @Override
        public void uncaughtException(Thread t, Throwable e) {
            // 处理异常，例如记录日志等
            System.err.println("Uncaught exception in thread " + t.getName() + ": " + e.getMessage());
        }
    }
    
    // 在任务提交给线程池之前设置自定义异常处理器
    Thread.setDefaultUncaughtExceptionHandler(new CustomExceptionHandler());

*使用线程池的异常处理机制：*  
某些线程池实现（如 ThreadPoolExecutor）提供了异常处理的机制，可以使用 setUncaughtExceptionHandler() 方法为线程池中的线程设置异常处理器。

ThreadPoolExecutor executor = new ThreadPoolExecutor(...);
    
    // 为线程池中的线程设置异常处理器
    executor.setUncaughtExceptionHandler(new CustomExceptionHandler());

*使用 Future 获取任务结果：*  
如果使用了 Future 来提交任务，并且任务可能抛出异常，可以通过 Future.get() 方法来获取任务的结果，并处理可能的异常。

ExecutorService executor = Executors.newFixedThreadPool(2);
    Future<?> future = executor.submit(() -> {
        // 任务逻辑可能抛出异常
    });
    
    try {
        // 获取任务结果，处理异常
        future.get();
    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }
    
    executor.shutdown();

通过合适的异常处理，可以确保线程池在任务执行过程中能够正确地处理异常情况，避免线程因为异常终止而影响应用程序的稳定性。

**10.适当关闭线程池：**  
在不再需要线程池时，通过调用合适的关闭方法（如 shutdown() 或 shutdownNow()）来关闭线程池，确保资源正确释放。

## 3、初谈 ThreadPoolExecutor ##

ThreadPoolExecutor 是 Java 中最常用的线程池实现类之一，它继承自 AbstractExecutorService 类，提供了一个灵活的线程池实现，可以自定义线程池的核心线程数、最大线程数、任务队列、拒绝策略等。以下是关于 ThreadPoolExecutor 类的一些重要信息和示例代码：

### 3.1、构造方法： ###

public ThreadPoolExecutor(int corePoolSize,
                                  int maximumPoolSize,
                                  long keepAliveTime,
                                  TimeUnit unit,
                                  BlockingQueue<Runnable> workQueue,
                                  ThreadFactory threadFactory,
                                  RejectedExecutionHandler handler)

corePoolSize：线程池的核心线程数，即始终保持存活的线程数。  
maximumPoolSize：线程池的最大线程数，包括核心线程数和非核心线程数。  
keepAliveTime：非核心线程的空闲存活时间。  
unit：时间单位，用于表示 keepAliveTime 的时间单位。

TimeUnit.DAYS：天
    TimeUnit.HOURS：小时
    TimeUnit.MINUTES：分钟
    TimeUnit.SECONDS：秒
    TimeUnit.MILLISECONDS：毫秒
    TimeUnit.MICROSECONDS：微秒
    TimeUnit.NANOSECONDS：纳秒

workQueue：任务队列，存储等待执行的任务。

LinkedBlockingQueue：LinkedBlockingQueue 是一个基于链表实现的阻塞队列。它具有无界或有界容量，即可以根据需要创建不同容量的队列。任务在队列中按照先进先出（FIFO）的顺序等待执行。由于是阻塞队列，当队列为空时，获取任务的线程会被阻塞，直到有新的任务被提交。
    
    ArrayBlockingQueue：ArrayBlockingQueue 是一个基于数组实现的有界阻塞队列。它具有固定的容量，任务在队列中按照先进先出的顺序等待执行。与 LinkedBlockingQueue 不同，ArrayBlockingQueue 的容量是固定的，因此在队列已满时，提交任务的线程会被阻塞。
    
    PriorityBlockingQueue：PriorityBlockingQueue 是一个支持优先级的无界阻塞队列。任务可以根据优先级进行排序，优先级高的任务会被优先执行。注意，该队列并不保证先进先出的顺序，而是根据优先级进行调度。
    
    DelayQueue：DelayQueue 是一个支持延迟执行的无界阻塞队列。其中的元素必须实现 Delayed 接口，可以指定元素在一定延迟时间后才能被取出。常用于实现定时任务的调度。
    
    SynchronousQueue：SynchronousQueue 是一个特殊的队列，其容量始终为 0。该队列用于直接传递任务，提交任务后必须等待其他线程立即接收，否则提交任务的线程会被阻塞。
    
    LinkedTransferQueue：LinkedTransferQueue 是一个无界阻塞队列，同时支持生产者-消费者模式和直接传递模式。任务可以直接传递给等待的消费者线程，也可以被放入队列中等待。

threadFactory：用于创建新线程的工厂。可以通过自定义线程工厂来设置线程的命名规则、优先级等。

Executors 类的工厂方法：Java 提供了 Executors 类，其中包含了一些工厂方法用于创建线程池和线程工厂。例如：
    
    	Executors.defaultThreadFactory()：返回默认的线程工厂，通常用于创建默认线程池。
    	Executors.privilegedThreadFactory()：返回一个线程工厂，将线程的创建委托给系统类加载器，可用于系统线程。
    	
    ThreadFactory 接口的自定义实现：可以实现 ThreadFactory 接口，创建自定义的线程工厂，以满足特定需求。通过自定义线程工厂，可以设置线程的命名规则、优先级、守护状态等。
    
    	public class CustomThreadFactory implements ThreadFactory {
    	    @Override
    	    public Thread newThread(Runnable runnable) {
    	        Thread thread = new Thread(runnable);
    	        thread.setName("MyThread-" + thread.getId());
    	        thread.setPriority(Thread.NORM_PRIORITY);
    	        thread.setDaemon(false);
    	        return thread;
    	    }
    	}
    
    
    Guava 的 ThreadFactoryBuilder：Guava 是 Google 提供的一个实用库，其中的 ThreadFactoryBuilder 类可以帮助创建自定义的线程工厂。它允许设置线程的名称、优先级、守护状态等。
    
    	ThreadFactory threadFactory = new ThreadFactoryBuilder()
    	    .setNameFormat("MyThread-%d")
    	    .setPriority(Thread.NORM_PRIORITY)
    	    .setDaemon(false)
    	    .build();

handler：拒绝策略，用于处理线程池无法接受新任务时的情况。

ThreadPoolExecutor.AbortPolicy（默认）：该策略会在无法处理新任务时抛出 `RejectedExecutionException` 异常，表示线程池已满且无法接受新任务。
    
    ThreadPoolExecutor.CallerRunsPolicy：该策略会将被拒绝的任务交给提交任务的线程来执行。这意味着提交任务的线程将执行被拒绝的任务，从而减缓任务提交的速度。
    
    ThreadPoolExecutor.DiscardPolicy：该策略会默默地丢弃被拒绝的任务，不会抛出异常也不会执行任务。
    
    ThreadPoolExecutor.DiscardOldestPolicy：该策略会丢弃队列中最旧的未执行任务，然后尝试提交当前被拒绝的任务。
    
    自定义拒绝策略：也可以实现 RejectedExecutionHandler 接口，创建自定义的拒绝策略。可以在自定义策略中根据实际需求执行特定的拒绝处理逻辑。

### 3.2、启动和停止任务的方法 ###

#### 提交任务： ####

使用 submit() 或 execute() 方法将任务提交给线程池，线程池会安排任务的执行。

ThreadPoolExecutor executor = new ThreadPoolExecutor(...);
    executor.submit(() -> {
        // 任务逻辑
    });
    executor.execute(() -> {
        // 任务逻辑
    });

**execute() 方法：**

没有返回值，不能获取任务的执行结果。
    只能用于提交 Runnable 类型的任务。
    如果任务执行抛出了异常，无法通过线程池直接获取到异常信息，需要自行处理异常。
    更加简洁，适用于不需要获取任务结果的情况。

**submit() 方法：**

返回一个 Future 对象，可以通过这个对象来获取任务的执行结果或异常信息。
    可以用于提交 Callable 或 Runnable 类型的任务。
    如果任务执行抛出了异常，可以通过 Future.get() 方法获取到异常信息，但需要注意异常的处理。
    更加灵活，适用于需要获取任务结果或异常信息的情况。

#### 关闭线程池： ####

通过 shutdown() 方法来关闭线程池。调用此方法后，线程池将不再接受新任务，但会等待已提交的任务执行完成。

executor.shutdown();

#### 立即关闭线程池： ####

使用 shutdownNow() 方法可以尝试立即关闭线程池。此方法会尝试停止所有正在执行的任务，并返回等待执行的任务列表。

List<Runnable> pendingTasks = executor.shutdownNow();

#### 等待线程池终止： ####

使用 awaitTermination() 方法可以等待线程池中的所有任务执行完成，并在指定的时间内等待线程池终止。

try {
        boolean terminated = executor.awaitTermination(timeout, TimeUnit.SECONDS);
    } catch (InterruptedException e) {
        // 处理中断异常
    }

请注意，一旦线程池被关闭，就不能再提交新的任务。根据实际需求，可以使用上述方法来管理线程池的任务执行和终止。

### 3.3、监控的方法 ###

#### **getActiveCount() 方法：** ####

获取当前活动线程的数量，即正在执行任务的线程数。

int activeCount = executor.getActiveCount();

#### getCompletedTaskCount() 方法： ####

获取已完成的任务数量。

long completedTaskCount = executor.getCompletedTaskCount();

#### getTaskCount() 方法：获取已提交的任务总数，包括已完成和未完成的任务。 ####

long totalTaskCount = executor.getTaskCount();

#### getQueue() 方法： ####

获取任务队列。可以通过这个方法获取当前等待执行的任务队列，并进行监控和分析。

BlockingQueue<Runnable> queue = executor.getQueue();

#### getPoolSize() 方法： ####

获取线程池当前的线程数量，包括核心线程和非核心线程。

int poolSize = executor.getPoolSize();

#### getLargestPoolSize() 方法： ####

获取线程池曾经达到的最大线程数量。

int largestPoolSize = executor.getLargestPoolSize();

#### 自定义监控和日志记录： ####

可以根据需求自行在任务执行前、执行后、异常处理等地方插入代码，进行自定义的监控和日志记录。例如，可以在任务的 run() 方法内部加入监控逻辑，记录任务的执行时间、状态等信息。

executor.execute(() -> {
        long startTime = System.currentTimeMillis();
        try {
            // 任务逻辑
        } catch (Exception e) {
            // 异常处理
        } finally {
            long endTime = System.currentTimeMillis();
            long executionTime = endTime - startTime;
            System.out.println("Task executed in " + executionTime + " ms");
        }
    });

通过这些方法和自定义监控逻辑，可以了解线程池的运行状况、任务执行情况和性能表现，从而进行合理的调优和监控。