线程池基本认识

1. 介绍

Java 线程池（Thread Pool）是 Java 并发编程中的一个重要概念，它通过重用一组线程来执行多个任务，从而提高应用程序的性能和资源利用率。Java 提供了多种方式来创建和管理线程池，主要通过 java.util.concurrent 包中的 Executor 框架。

2. 作用

1. 减少线程创建和销毁的开销：线程池通过重用现有线程来执行任务，避免了频繁创建和销毁线程的开销。
2. 提高响应速度：当任务到达时，如果有空闲线程，任务可以立即执行，而不需要等待新线程的创建。
3. 更好的资源管理：线程池可以限制线程的数量，防止系统资源被耗尽。

3. 主要类型

1. FixedThreadPool：固定大小的线程池。
2. CachedThreadPool：根据需要创建新线程的线程池，但在先前构建的线程可用时将重用它们。
3. SingleThreadExecutor：单线程的线程池。
4. ScheduledThreadPool：支持定时和周期性任务执行的线程池。

4. 详细介绍

4.1 基本关系图

4.2 介绍

4.2.1 Executor相关

Executor线程池框架的基础，任务的执行者接口，用于解耦任务的提交和执行。提供了一个execute()方法，用来执行已经提交的Runnable任务。

public interface Executor {
    
    void execute(Runnable command);
}

1. ExecutorService
   ExecutorService是Executor的子接口，提供了更丰富的功能来管理任务的执行和生命周期。

public interface ExecutorService extends Executor {
    // 启动有序关闭，在关闭前执行已提交的任务，但不接受新任务。
    void shutdown();

    // 试图停止所有正在执行的任务，暂停等待任务的处理，并返回等待执行的任务列表。
    List<Runnable> shutdownNow();

    // 如果此执行程序已关闭，则返回 true。
    boolean isShutdown();

    // 如果关闭后所有任务都已完成，则返回 true
    boolean isTerminated();

    //  请求关闭、发生超时或者当前线程中断，都将导致阻塞，直到所有任务完成执行
    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;

    // 提交一个返回值的任务，用于执行并返回一个 Future 表示任务的结果。
    <T> Future<T> submit(Callable<T> task);

    // 提交一个 Runnable 任务并返回一个 Future，该 Future 的 get 方法将在成功完成时返回给定的结果。
    <T> Future<T> submit(Runnable task, T result);

    // 提交一个 Runnable 任务并返回一个 Future，该 Future 的 get 方法将在成功完成时返回 null。
    Future<?> submit(Runnable task);


    // 执行给定的任务，当所有任务完成时，返回保持任务状态和结果的 Future 列表。
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;

    // 执行给定的任务，当所有任务完成或超时期满时，返回保持任务状态和结果的 Future 列表
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                  long timeout, TimeUnit unit)
        throws InterruptedException;


    // 执行给定的任务，当一个任务成功完成（即没有抛出异常）时，返回其结果。
    <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;

    // 执行给定的任务，如果在给定的超时期满前某个任务已成功完成（也就是未抛出异常），则返回其结果
    <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                    long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

2. AbstractExecutorService
   AbstractExecutorService是 ExecutorService 接口的一个抽象实现类，它提供了一些基本的实现，简化了自定义 ExecutorService 的创建过程。通过继承 AbstractExecutorService，可以专注于实现核心的任务执行逻辑。
3. ScheduledExecutorService
   ScheduledExecutorService 是 ExecutorService 的一个子接口，位于 java.util.concurrent 包中。它提供了调度任务执行的功能，可以在给定的延迟后执行任务，或者以固定的速率或固定的延迟重复执行任务。

public interface ScheduledExecutorService extends ExecutorService {


    // 在给定的延迟后执行一次 Runnable 任务。
    public ScheduledFuture<?> schedule(Runnable command,
                                       long delay, TimeUnit unit);

    // 在给定的延迟后执行一次 Callable 任务，并返回一个 ScheduledFuture 表示任务的结果。
    public <V> ScheduledFuture<V> schedule(Callable<V> callable,
                                           long delay, TimeUnit unit);


    // 以固定的速率重复执行 Runnable 任务，任务开始执行后，
    // 下一次执行的时间点是上一次任务开始执行的时间点加上 period。
    public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                                                  long initialDelay,
                                                  long period,
                                                  TimeUnit unit);

    // 以固定的延迟重复执行 Runnable 任务，任务开始执行后，
    // 下一次执行的时间点是上一次任务结束执行的时间点加上 delay。
    public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                     long initialDelay,
                                                     long delay,
                                                     TimeUnit unit);

}

4. ThreadPoolExecutor
   ThreadPoolExecutor 是 Java 中 ExecutorService 接口的一个实现类。它是一个功能强大的线程池实现，提供了灵活的线程管理和任务调度机制。ThreadPoolExecutor 允许你配置线程池的核心参数，如核心线程数、最大线程数、线程空闲时间、任务队列等。

5. ScheduledThreadPoolExecutor
   ScheduledThreadPoolExecutor 是 ThreadPoolExecutor 的一个子类。它扩展了 ThreadPoolExecutor，提供了调度任务执行的功能，可以在给定的延迟后执行任务，或者以固定的速率或固定的延迟重复执行任务。同时ScheduledThreadPoolExecutor 是 ScheduledExecutorService 接口的一个实现类。

6. Executors
   Executors 是 Java 中的一个工具类。它提供了一些静态工厂方法，用于创建不同类型的ExecutorService实现，包括线程池、调度线程池和单线程执行器等。Executors 类简化了线程池的创建和管理，使得开发者可以更方便地使用线程池来管理并发任务。

• 创建并返回设置有常用配置字符串的 ExecutorService
  的方法，例如：固定大小的线程池（newFixedThreadPool）、单线程执行器（newSingleThreadExecutor）、可缓存的线程池（newCachedThreadPool）。
• 创建并返回设置有常用配置字符串的 ScheduledExecutorService
  的方法，例如：创建调度线程池（newScheduledThreadPool）。
• 创建并返回包装的 ExecutorService 方法，它通过使特定于实现的方法不可访问来禁用重新配置。例如：创建一个包装的 ExecutorService
  实例（unconfigurableExecutorService）
• 创建并返回 ThreadFactory的方法，它可将新创建的线程设置为已知的状态。 ● 创建并返回非闭包形式的 Callable 的方法，这样可将其用于需要 Callable
  的执行方法中。

4.2.2 Future 相关

Future 和 FutureTask 是用于处理异步计算的两个重要组件。Future 是一个接口，而 FutureTask 是其一个具体实现。它们在并发编程中扮演着重要角色，帮助开发者管理和控制异步任务的执行。

1. Future
   Future 接口是 java.util.concurrent 包的一部分，用于表示异步计算的结果。Future 提供了一种方法来检查计算是否完成、等待计算完成并获取计算结果。它还可以取消计算任务。

public interface Future<V> {

    // 尝试取消任务的执行。
    // mayInterruptIfRunning: 如果任务正在运行，是否允许中断它。
    // 返回值: 如果任务成功取消则返回 true，否则返回 false。
    boolean cancel(boolean mayInterruptIfRunning);

    // 如果任务在正常完成前被取消，则返回 true。
    boolean isCancelled();

    // 如果任务已完成，无论是正常完成、被取消还是抛出异常，则返回 true。
    boolean isDone();

    // 等待任务完成并获取其结果。
    // 如果任务被取消或抛出异常，则抛出相应的异常。
    V get() throws InterruptedException, ExecutionException;

    // 等待任务在指定的时间内完成并获取其结果。
    // 如果在超时时间内任务未完成，则抛出 TimeoutException。
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

2. RunnableFuture
   RunnableFuture 是 Java 并发包 (java.util.concurrent) 中的一个接口，它结合了 Runnable 和 Future 的功能。RunnableFuture 继承了 Runnable 和 Future 接口，因此它既可以作为一个任务提交给 ExecutorService 执行，又可以用来获取任务的结果或取消任务。

public interface RunnableFuture<V> extends Runnable, Future<V> {
    /**
     * 未被取消情况下，将此Future设置为其计算的结果
     */
    void run();
}

3. FutureTask
   FutureTask 实现了 RunnableFuture 接口。FutureTask 可以用来包装 Callable或 Runnable 对象，并且可以提交给 ExecutorService 执行。它既可以作为一个任务提交给线程池执行，又可以用来获取任务的结果或取消任务。