Java线程池种类及具体应用场景

Java线程池种类及具体应用场景

在实际开发中，选择合适的线程池类型至关重要，不同场景有不同的线程池需求。本文将结合线程池种类和具体应用示例，详细说明每种线程池的使用场景和适用情况。

一、固定大小线程池（FixedThreadPool）

特点

• 线程数量固定：线程池中的线程数固定，超过的任务会被放入队列等待执行。
• 任务队列无界：会保存所有等待执行的任务。

适用场景

适用于任务量确定且需要长期运行的场景，例如：

• 处理固定数量的并发任务。
• 需要对线程数量严格控制，避免资源耗尽。

应用示例：文件批量处理

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

public class FixedThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);

        // 模拟批量处理文件
        for (int i = 1; i <= 10; i++) {
            int fileNumber = i;
            fixedThreadPool.execute(() -> {
                System.out.println(Thread.currentThread().getName() + " 正在处理文件 " + fileNumber);
                try {
                    Thread.sleep(1000); // 模拟文件处理耗时
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        fixedThreadPool.shutdown();
    }
}

输出示例：

pool-1-thread-1 正在处理文件 1
pool-1-thread-2 正在处理文件 2
pool-1-thread-3 正在处理文件 3

二、单线程池（SingleThreadExecutor）

特点

• 单线程：始终只有一个线程执行任务，任务按提交顺序依次执行。
• 任务队列无界：任务不会丢失。

适用场景

适用于需要按顺序执行任务的场景，例如：

• 日志写入。
• 数据库备份任务。

应用示例：按顺序写入日志

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

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

        // 模拟日志写入
        for (int i = 1; i <= 5; i++) {
            int logNumber = i;
            singleThreadExecutor.execute(() -> {
                System.out.println("写入日志：" + logNumber);
            });
        }

        singleThreadExecutor.shutdown();
    }
}

输出示例：

写入日志：1
写入日志：2
写入日志：3

三、可缓存线程池（CachedThreadPool）

特点

• 线程数动态增长：没有核心线程，所有任务都创建新线程处理；线程空闲超时后会被销毁。
• 任务队列无界：适合短期大量任务。

适用场景

适用于执行大量短生命周期的任务，例如：

• 服务器处理大量临时任务。
• 并发测试。

应用示例：并发请求处理

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

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

        // 模拟并发请求
        for (int i = 1; i <= 10; i++) {
            int requestNumber = i;
            cachedThreadPool.execute(() -> {
                System.out.println(Thread.currentThread().getName() + " 正在处理请求 " + requestNumber);
            });
        }

        cachedThreadPool.shutdown();
    }
}

输出示例：

pool-1-thread-1 正在处理请求 1
pool-1-thread-2 正在处理请求 2
pool-1-thread-3 正在处理请求 3

四、定时任务线程池（ScheduledThreadPool）

特点

• 支持定时和周期性任务：可以延迟执行任务，也可以周期性执行任务。
• 线程数固定：线程池大小由开发者设置。

适用场景

适用于需要定时或周期性执行任务的场景，例如：

• 定时任务提醒。
• 周期性数据同步。

应用示例：定时任务调度

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 scheduledThreadPool = Executors.newScheduledThreadPool(2);

        // 延迟3秒执行任务
        scheduledThreadPool.schedule(() -> {
            System.out.println("任务延迟3秒后执行");
        }, 3, TimeUnit.SECONDS);

        // 每2秒执行一次任务
        scheduledThreadPool.scheduleAtFixedRate(() -> {
            System.out.println("周期任务，每2秒执行一次");
        }, 1, 2, TimeUnit.SECONDS);

        // 每3秒执行一次任务
        scheduledThreadPool.scheduleWithFixedDelay(() -> {
            System.out.println("固定延迟任务，每3秒延迟执行");
        }, 1, 3, TimeUnit.SECONDS);
    }
}

五、自定义线程池

特点

• 根据业务需求灵活配置参数。
• 通过自定义拒绝策略、任务队列、线程工厂等满足特定需求。

适用场景

适用于对线程池有特殊要求的场景，例如：

• 限制任务队列大小。
• 自定义日志记录线程工厂。

应用示例：控制线程数量并记录日志

import java.util.concurrent.*;

public class CustomThreadPoolExample {
    public static void main(String[] args) {
        ThreadPoolExecutor customThreadPool = new ThreadPoolExecutor(
            2, // 核心线程数
            4, // 最大线程数
            60, // 空闲线程存活时间
            TimeUnit.SECONDS, // 时间单位
            new ArrayBlockingQueue<>(2), // 有界队列
            r -> { // 自定义线程工厂
                Thread thread = new Thread(r);
                thread.setName("自定义线程-" + thread.getId());
                return thread;
            },
            new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
        );

        for (int i = 1; i <= 10; i++) {
            int taskNumber = i;
            customThreadPool.execute(() -> {
                System.out.println(Thread.currentThread().getName() + " 正在执行任务 " + taskNumber);
                try {
                    Thread.sleep(1000); // 模拟任务耗时
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        customThreadPool.shutdown();
    }
}

总结

根据实际场景选择合适的线程池，既能优化系统性能，又能合理分配资源。