四种常见的线程池

Java中四种常见的线程池包括newSingleThreadExecutor、newFixedThreadPool、newScheduledThreadPool和newCachedThreadPool。

• newSingleThreadExecutor：创建一个单线程的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定的顺序（FIFO, LIFO, 优先级）执行。这种线程池适用于需要保证任务顺序执行的场景。

public class SingleThreadExecutorExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();

        // 提交任务到线程池
        executor.submit(() -> {
            System.out.println("Task 1 is running");
        });

        executor.submit(() -> {
            System.out.println("Task 2 is running");
        });

        // 关闭线程池
        executor.shutdown();
    }
}

 newSingleThreadExecutor

  ThreadPoolExecutor executor = new ThreadPoolExecutor
(1, 1, 0L, 
TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(), 
threadFactory);

核心线程数（corePoolSize）1

最大线程数（maximumPoolSize) 1

空闲线程存活时间（keepAliveTime) 0

时间单位（TimeUnit）纳秒

任务队列（workQueue） LinkedBlockingQueue(无界队列)

• newFixedThreadPool：创建一个定长线程池，可以控制线程的最大并发数，超出的线程会在队列中等待。这种线程池适用于需要限制并发线程数量的场景，以避免过多的线程竞争资源导致系统负载过高。

public class FixedThreadPoolExample {
    public static void main(String[] args) {
        int numberOfThreads = 5; // 设置最大并发数为5
        ExecutorService executor = Executors.newFixedThreadPool(numberOfThreads);

        for (int i = 0; i < 10; i++) {
            executor.submit(() -> {
                System.out.println("Task " + i + " is running");
            });
        }

        // 关闭线程池
        executor.shutdown();
    }
}

 newFixedThreadPool

ThreadPoolExecutor executor = new ThreadPoolExecutor
(5, 5, 0L, 
TimeUnit.MILLISECONDS, 
new LinkedBlockingQueue<Runnable>(), 
threadFactory);

核心线程数（corePoolSize）用户指定

最大线程数（maximumPoolSize)   = 核心线程数（corePoolSize）

空闲线程存活时间（keepAliveTime) 0

时间单位（TimeUnit）毫秒

任务队列（workQueue） LinkedBlockingQueue(无界队列)

• newScheduledThreadPool：创建一个可定期或延时执行任务的定长线程池，支持定时及周期性任务执行。这种线程池适用于需要定时或周期性执行任务的场景，如定时清理缓存、定时发送心跳包等。

public class ScheduledThreadPoolExample {
    public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(2);

        // 延迟2秒后执行任务
        executor.schedule(() -> {
            System.out.println("Task 1 is running after 2 seconds");
        }, 2, TimeUnit.SECONDS);

        // 每隔3秒执行一次任务
        executor.scheduleAtFixedRate(() -> {
            System.out.println("Task 2 is running every 3 seconds");
        }, 0, 3, TimeUnit.SECONDS);

        // 关闭线程池
        executor.shutdown();
    }
}

 newScheduledThreadPool

public ScheduledThreadPoolExecutor(int corePoolSize) {super
(corePoolSize, 
Integer.MAX_VALUE,
 0, NANOSECONDS,
new DelayedWorkQueue());
}

核心线程数（corePoolSize）指定的线程数

最大线程数（maximumPoolSize) Integer.MAX_VALUE, 无限大

空闲线程存活时间（keepAliveTime) 0

时间单位（TimeUnit）纳秒

任务队列（workQueue） DelayedWorkQueue

• newCachedThreadPool：创建一个可缓存线程池，如果线程池长度超过处理需要，可以灵活回收空闲线程，若无可回收，则新建线程。这种线程池适用于任务执行时间较短且频繁创建线程的场景，如Web服务器处理用户请求。

public class CachedThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();

        for (int i = 0; i < 10; i++) {
            executor.submit(() -> {
                System.out.println("Task " + i + " is running");
            });
        }

        // 关闭线程池
        executor.shutdown();
    }
}

newCachedThreadPool

ThreadPoolExecutor executor = new ThreadPoolExecutor
(0, Integer.MAX_VALUE, 60L, 
TimeUnit.SECONDS, 
new SynchronousQueue<Runnable>(),
threadFactory);

核心线程数（corePoolSize）0

最大线程数（maximumPoolSize) Integer.MAX_VALUE  

空闲线程存活时间（keepAliveTime) 60

时间单位（TimeUnit）秒

任务队列（workQueue） SynchronousQueue