Java线程池工厂使用详解

如何使用Executors创建线程池？1.使用newFixedThreadPool(int nThreads)创建固定大小的线程池；2.使用newCachedThreadPool()创建可缓存线程池；3.使用newSingleThreadExecutor()创建单线程线程池；4.使用newScheduledThreadPool(int corePoolSize)创建支持定时和周期任务的线程池。线程池的拒绝策略是什么？如何自定义拒绝策略？默认使用AbortPolicy，其他内置策略包括CallerRunsPolicy、DiscardPolicy和DiscardOldestPolicy，自定义需实现RejectedExecutionHandler接口并在创建线程池时传入。如何优雅地关闭线程池？调用shutdown()平滑关闭，调用shutdownNow()立即停止任务，结合awaitTermination()等待任务完成或超时处理。如何监控线程池的状态？通过getPoolSize()、getActiveCount()、getCompletedTaskCount()、getTaskCount()和getQueue().size()获取状态信息。Executors创建的线程池有什么缺点？其队列容量过大可能导致OOM，newCachedThreadPool可能创建过多线程耗尽资源，推荐手动使用ThreadPoolExecutor创建以精确控制参数并避免风险。

Executors类是Java并发包中一个强大的工具类，它简化了线程池的创建和管理，提供了一系列静态工厂方法，帮助开发者快速构建各种类型的线程池，而无需深入了解线程池的底层细节。

Executors类主要用于创建不同类型的线程池，它隐藏了线程池的复杂性，使开发者能够更专注于任务的执行。

如何使用Executors创建线程池？

Executors类提供了多种静态工厂方法，用于创建不同类型的线程池，以下是一些常用的方法：

• newFixedThreadPool(int nThreads): 创建一个固定大小的线程池，池中始终保持指定数量的线程。如果所有线程都在忙碌，新的任务将被放入队列中等待。

  

  ExecutorService executor = Executors.newFixedThreadPool(10);
  for (int i = 0; i < 100; i++) {
      executor.execute(new Task(i));
  }
  executor.shutdown();

• newCachedThreadPool(): 创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需的数量，会自动回收空闲线程。当有新任务提交时，如果没有空闲线程可用，则会创建新的线程。这种线程池非常适合处理大量的短期异步任务。

  ExecutorService executor = Executors.newCachedThreadPool();
  for (int i = 0; i < 100; i++) {
      executor.execute(new Task(i));
  }
  executor.shutdown();

• newSingleThreadExecutor(): 创建一个单线程的线程池。所有提交的任务都会按照先进先出的顺序执行。如果线程在执行任务时发生异常，会创建一个新的线程来替代它，保证所有任务都会被执行。

  ExecutorService executor = Executors.newSingleThreadExecutor();
  for (int i = 0; i < 100; i++) {
      executor.execute(new Task(i));
  }
  executor.shutdown();

• newScheduledThreadPool(int corePoolSize): 创建一个可以执行定时任务和周期性任务的线程池。

  ScheduledExecutorService executor = Executors.newScheduledThreadPool(5);
  executor.scheduleAtFixedRate(new Task(1), 1, 3, TimeUnit.SECONDS); // 每隔3秒执行一次，延迟1秒后开始执行

线程池的拒绝策略是什么？如何自定义拒绝策略？

当线程池的任务队列已满，且线程池中的所有线程都在忙碌时，如果再有新的任务提交，线程池会使用拒绝策略来处理这些任务。Executors创建的线程池默认使用ThreadPoolExecutor.AbortPolicy，该策略会直接抛出RejectedExecutionException异常。

Java提供了四种内置的拒绝策略：

• AbortPolicy: 默认策略，直接抛出RejectedExecutionException异常。
• CallerRunsPolicy: 由提交任务的线程来执行该任务。
• DiscardPolicy: 直接丢弃该任务，不抛出异常。
• DiscardOldestPolicy: 丢弃队列中最老的未处理任务，然后尝试执行当前任务。

当然，你也可以自定义拒绝策略，只需要实现RejectedExecutionHandler接口即可：

import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;

public class CustomRejectedExecutionHandler implements RejectedExecutionHandler {
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        System.out.println("Task " + r.toString() + " rejected from " + executor.toString());
        // 可以添加自定义的拒绝处理逻辑，例如记录日志、持久化任务等
    }
}

然后，在创建线程池时，将自定义的拒绝策略传递给ThreadPoolExecutor的构造函数：

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Main {
    public static void main(String[] args) {
        int corePoolSize = 5;
        int maxPoolSize = 10;
        long keepAliveTime = 5000;
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                corePoolSize,
                maxPoolSize,
                keepAliveTime,
                TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<>(100), // 任务队列
                new CustomRejectedExecutionHandler() // 自定义拒绝策略
        );

        for (int i = 0; i < 200; i++) {
            executor.execute(new Task(i));
        }

        executor.shutdown();
    }
}

如何优雅地关闭线程池？shutdown()和shutdownNow()有什么区别？

关闭线程池是一个重要的步骤，它可以防止资源泄漏。Executors创建的线程池提供了两种关闭方法：shutdown()和shutdownNow()。

• shutdown(): 平滑关闭线程池。它会阻止新的任务提交，但会等待所有已提交的任务执行完成。

• shutdownNow(): 立即关闭线程池。它会尝试停止所有正在执行的任务，并返回一个包含所有等待执行的任务的列表。需要注意的是，shutdownNow()方法并不能保证所有任务都会被立即停止，因为某些任务可能正在执行一些无法中断的操作。

在调用shutdown()或shutdownNow()方法后，可以使用awaitTermination()方法来等待线程池中的所有任务执行完成，或者等待指定的超时时间。

ExecutorService executor = Executors.newFixedThreadPool(10);
// 提交任务...
executor.shutdown(); // 阻止新的任务提交
try {
    if (!executor.awaitTermination(60, TimeUnit.SECONDS)) { // 等待60秒
        executor.shutdownNow(); // 如果超时，则尝试立即停止所有任务
    }
} catch (InterruptedException e) {
    executor.shutdownNow(); // 如果当前线程被中断，则尝试立即停止所有任务
}

如何监控线程池的状态？

监控线程池的状态对于诊断性能问题和优化线程池配置非常重要。ThreadPoolExecutor类提供了一些方法来获取线程池的状态信息：

• getPoolSize(): 返回线程池中的线程数量。
• getActiveCount(): 返回正在执行任务的线程数量。
• getCompletedTaskCount(): 返回已完成的任务数量。
• getTaskCount(): 返回已提交的任务总数。
• getQueue().size(): 返回任务队列中的任务数量。

你可以使用这些方法来定期监控线程池的状态，并根据需要调整线程池的配置。例如，如果getQueue().size()持续增长，说明任务提交的速度超过了线程池的处理能力，可能需要增加线程池的大小。

ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);
// 提交任务...

while (true) {
    System.out.println("Pool Size: " + executor.getPoolSize());
    System.out.println("Active Count: " + executor.getActiveCount());
    System.out.println("Completed Task Count: " + executor.getCompletedTaskCount());
    System.out.println("Task Count: " + executor.getTaskCount());
    System.out.println("Queue Size: " + executor.getQueue().size());
    Thread.sleep(1000); // 每隔1秒打印一次状态信息
}

Executors创建的线程池有什么缺点？为什么推荐使用ThreadPoolExecutor手动创建？

虽然Executors类简化了线程池的创建，但它也存在一些缺点：

• newFixedThreadPool()和newSingleThreadExecutor(): 它们的任务队列使用了LinkedBlockingQueue，该队列的默认容量是Integer.MAX_VALUE。如果任务提交的速度超过了线程池的处理能力，会导致大量的任务堆积在队列中，最终可能导致OOM（OutOfMemoryError）异常。

• newCachedThreadPool(): 它可以创建无限数量的线程，如果任务提交的速度过快，可能会创建大量的线程，导致系统资源耗尽。

因此，阿里巴巴Java开发手册中建议使用ThreadPoolExecutor手动创建线程池，而不是使用Executors类。手动创建线程池可以更精确地控制线程池的参数，例如核心线程数、最大线程数、任务队列的类型和容量、拒绝策略等，从而避免潜在的风险。

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Main {
    public static void main(String[] args) {
        int corePoolSize = 5;
        int maxPoolSize = 10;
        long keepAliveTime = 5000;
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                corePoolSize,
                maxPoolSize,
                keepAliveTime,
                TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<>(100) // 任务队列，设置容量
        );

        for (int i = 0; i < 200; i++) {
            executor.execute(new Task(i));
        }

        executor.shutdown();
    }
}

总之，Executors类是Java并发编程中一个非常有用的工具，但需要了解其潜在的风险，并根据实际情况选择合适的线程池创建方式。在大多数情况下，推荐使用ThreadPoolExecutor手动创建线程池，以便更好地控制线程池的参数，并避免潜在的OOM风险。