【Java 中创建线程池的方式】

以下是一些常见线程池的创建方式：

1. 使用ThreadPoolExecutor自定义创建线程池

这是企业中最推荐的做法，因为它提供了最大的灵活性。

特性与特点：允许精确控制线程池的核心参数，如核心线程数、最大线程数、任务队列容量、线程空闲时间以及饱和策略等。

import java.util.concurrent.*;

public class CustomThreadPool {
    public static void main(String[] args) {
        // 自定义线程池配置
        int corePoolSize = 5; // 核心线程数
        int maximumPoolSize = 10; // 最大线程数
        long keepAliveTime = 60L; // 空闲线程存活时间
        TimeUnit unit = TimeUnit.SECONDS; // 时间单位
        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(20); // 任务队列
        ThreadFactory threadFactory = Executors.defaultThreadFactory(); // 线程工厂
        RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy(); // 拒绝策略
        
        ExecutorService executor = new ThreadPoolExecutor(
                corePoolSize,
                maximumPoolSize,
                keepAliveTime,
                unit,
                workQueue,
                threadFactory,
                handler
        );
        
        // 提交任务到线程池
        for (int i = 0; i < 15; i++) {
            executor.submit(() -> {
                System.out.println("Task executed by " + Thread.currentThread().getName());
            });
        }
        
        // 关闭线程池
        executor.shutdown();
    }
}

核心参数：

• corePoolSize：核心线程数。
• maximumPoolSize：最大线程数。
• keepAliveTime：空闲线程存活时间。
• workQueue：任务队列，用于存储等待执行的任务。
• threadFactory：线程工厂，用于创建新线程。
• handler：拒绝策略，当线程池无法处理新任务时采取的策略。

执行任务流程

• execute(Runnable command)：这是提交任务到线程池的主要方法。

其执行流程大致如下：

1. 直接执行：如果当前运行的线程少于核心线程数，即使其他线程是空闲的，也会尝试直接创建一个新的线程来执行任务。
2. 加入队列：如果当前线程数等于核心线程数，任务将被放入工作队列中排队。
3. 扩容线程池：如果工作队列已满，且当前线程数小于最大线程数，会创建新的线程来处理任务。
4. 拒绝策略：如果当前线程数已经达到最大值，且工作队列也满了，就会触发拒绝策略，通常是抛出异常或忽略该任务。

2. 使用Executors工厂方法

2.1. FixedThreadPool（固定大小线程池）

描述: 创建一个固定大小的线程池，该线程池可重用固定数量的线程。如果所有线程都在活动状态，新提交的任务将在队列中等待，直到有线程可用。
特点：线程池大小固定，所有线程都会一直存在直到程序结束，适合于执行大量相似任务的场景。
使用场景：适用于负载较稳定的场景，尤其是当任务数和线程处理能力相对均衡时。

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>());
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class FixedThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个固定大小为5的线程池
        ExecutorService executor = Executors.newFixedThreadPool(5);
        
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executor.execute(() -> {
                System.out.println("Task ID " + taskId + " is running in " + Thread.currentThread().getName());
            });
        }
        
        // 关闭线程池（最好在应用程序结束时执行）
        executor.shutdown();
        while (!executor.isTerminated()) {
            // 等待所有任务完成
        }
        System.out.println("Finished all threads");
    }
}

2.2. CachedThreadPool（可缓存线程池）

描述: 创建一个可根据需要创建新线程的线程池，线程池在需要时创建新线程，如果现有线程空闲超过60秒，则会被回收。
特点：线程池会根据需要创建新线程，如果有空闲线程则重用，否则新建。空闲线程在默认情况下存活60秒后被终止。
使用场景：适用于执行很多短期异步任务，如处理HTTP请求、执行短小的后台任务。

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

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CachedThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();
        
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executor.execute(() -> {
                System.out.println("Task ID " + taskId + " is running in " + Thread.currentThread().getName());
            });
        }
        
        executor.shutdown();
    }
}

2.3. SingleThreadExecutor（单线程线程池）

描述: 创建一个只有一个线程的线程池，所有任务按照提交顺序依次执行。
特点：该线程池只使用一个线程来执行任务，任务按照提交顺序执行，适用于不需要并发但需要顺序处理的场景。
使用场景：适用于需要保证顺序执行任务的场景，或作为后台任务处理器。

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                               0L, TimeUnit.MILLISECONDS,
                               new LinkedBlockingQueue<Runnable>()));
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SingleThreadExecutorExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executor.execute(() -> {
                System.out.println("Task ID " + taskId + " is running in " + Thread.currentThread().getName());
            });
        }
        
        executor.shutdown();
    }
}

2.4. ScheduledThreadPool（定时/周期性任务线程池）

描述: 创建一个支持定时及周期性执行任务的线程池。核心线程数固定，其余线程在无任务时会被回收。
特点：可以安排任务在未来的某个时间点执行，或者定期重复执行。适用于定时任务和周期性任务。
使用场景：执行定时任务，如定时数据同步、定时清理、定时检查等。

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledThreadPoolExample {
    public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(5);
        
        Runnable task = () -> System.out.println("Task executed at " + System.currentTimeMillis());
        
        // 延迟5秒后执行一次
        executor.schedule(task, 5, TimeUnit.SECONDS);
        
        // 每隔3秒执行一次
        executor.scheduleAtFixedRate(task, 0, 3, TimeUnit.SECONDS);
        
        // 在关闭前，通常应有逻辑来决定何时停止调度
        // 这里为了简化，直接关闭线程池，但在实际应用中应避免立即关闭以免任务未完成
        executor.shutdown();
        while (!executor.isTerminated()) {}
        System.out.println("Finished all scheduled tasks");
    }
}

底层实现
上述所有Executors工厂方法创建线程池的实现最终都基于ThreadPoolExecutor类，它内部维护了工作线程集合、任务队列、同步控制锁等，以确保任务能够高效、安全地分配给线程执行，并处理线程的生命周期管理、任务调度和拒绝策略等问题。自定义配置线程池时，通过调整ThreadPoolExecutor的构造参数，可以针对特定应用场景优化性能和资源利用率。

特性总结

• 灵活性: Executors提供的工厂方法简化了线程池的创建，使得开发者无需直接与ThreadPoolExecutor复杂的构造参数打交道。
• 易用性: 提供了多种预设的线程池模型，满足不同场景下的需求。
• 潜在风险: 尽管方便，但直接使用这些方法可能会导致资源管理不当（如无限增长的队列、过多线程），因此现代实践中更推荐直接使用ThreadPoolExecutor进行定制化配置，以更好地控制和理解线程池的行为。