一：六种常用线程池

Java的Executor框架提供了许多线程池实现，其中最常用的有以下六种：

1. FixedThreadPool（有限线程数的线程池）
2. CachedThreadPool（无限线程数的线程池）
3. ScheduledThreadPool（定时线程池）
4. SingleThreadExecutor（单一线程池）
5. SingleThreadScheduledExecutor（单一定时线程池）
6. ForkJoinPool（分治线程池）

二：如何进行使用

2.1FixedThreadPool（有限线程数的线程池）

FixedThreadPool是一种有限线程数的线程池，它的核心线程数和最大线程数是一致的，线程数是固定的。一旦线程池的大小达到了最大值，再有新的任务提交时，就会放入无界阻塞队列中，等到有线程空闲时再从队列中取出任务继续执行。

如何使用

1. 实例化线程池对象

ExecutorService executorService = Executors.newFixedThreadPool(60);

2. 创建任务

public class PrintTask implements Runnable{
    public void run(){
        // 任务执行代码
    }
}

3. 提交任务

executorService.submit(new PrintTask());

4. 手动关闭线程池
   在程序结束时，应该手动关闭线程池以释放资源。

executorService.shutdown();

2.2CachedThreadPool（无限线程数的线程池）

CachedThreadPool是一种无限线程数的线程池，线程数会根据需要自动增加或减少。如果有任务需要执行，且当前没有空闲线程可用，就会创建一个新的线程执行任务。当线程空闲时间超过60秒时，就会被回收。因此，CachedThreadPool适用于执行大量短期异步任务的场景。
如何使用

1. 实例化线程池对象

ExecutorService executorService = Executors.newCachedThreadPool();

2. 创建任务

public class PrintTask implements Runnable{
    public void run(){
        // 任务执行代码
    }
}

3. 提交任务

executorService.submit(new PrintTask());

4. 手动关闭线程池
   在程序结束时，应该手动关闭线程池以释放资源。

executorService.shutdown();

2.3 ScheduledThreadPool（定时线程池）

ScheduledThreadPool是一种定时线程池，它可以在指定的时间执行任务，也可以定期执行任务。ScheduledThreadPool具有定时执行、周期执行、延迟执行等特点，适用于定时任务和周期任务。
** 如何使用**

1. 实例化线程池对象

ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);

2. 创建任务

public class PrintTask implements Runnable{
    public void run(){
        // 任务执行代码
    }
}

3. 提交任务

// 延迟执行任务
scheduledExecutorService.schedule(new PrintTask(), 5, TimeUnit.SECONDS);

2.4 SingleThreadExecutor（单一线程池）

SingleThreadExecutor 是只有一个线程的线程池，它的特点是保证所有任务都在同一线程中按顺序执行，可以避免多线程情况下的竞争和死锁问题。适用于需要按顺序执行多个任务的场景，例如日志记录、任务提交等。

// 实例化单一线程池
ExecutorService executorService = Executors.newSingleThreadExecutor();

// 创建任务并提交到单一线程池
executorService.submit(new Runnable() {
    @Override
    public void run() {
        // 任务执行的代码
    }
});

// 手动关闭线程池
executorService.shutdown();

2.5 SingleThreadScheduledExecutor（单一定时线程池）

SingleThreadScheduledExecutor 是只有一个线程的定时线程池，它的特点是在给定延迟后按指定的时间周期性地执行任务。适用于需要延迟执行任务、周期性执行任务的场景，例如定时任务、定时检测等。

// 实例化单一定时线程池
ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();

// 延迟一段时间后执行任务
scheduledExecutorService.schedule(new Runnable() {
    @Override
    public void run() {
        // 任务执行的代码
    }
}, 10, TimeUnit.SECONDS);

// 延迟一段时间后，按指定时间间隔周期性地执行任务
scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
    @Override
    public void run() {
        // 任务执行的代码
    }
}, 10, 5, TimeUnit.SECONDS);

// 手动关闭线程池
scheduledExecutorService.shutdown();

2.6 ForkJoinPool（分治线程池）

ForkJoinPool 是一种特殊的线程池，它的特点是将大任务分解成多个小任务，然后将这些小任务分配给不同的线程执行，最后将小任务的执行结果合并成大任务的结果。适用于需要分解大任务并发执行的场景，例如并行排序、MapReduce 等。

// 实例化分治线程池
ForkJoinPool forkJoinPool = new ForkJoinPool();

// 创建大任务
RecursiveTask<Integer> task = new RecursiveTask<Integer>() {
    @Override
    protected Integer compute() {
        // 将大任务分解成多个小任务
        List<RecursiveTask<Integer>> subTasks = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            RecursiveTask<Integer> subTask = new RecursiveTask<Integer>() {
                @Override
                protected Integer compute() {
                    // 小任务的执行代码
                }
            };
            subTasks.add(subTask);
        }

        // 执行所有小任务
        invokeAll(subTasks);

        // 将所有小任务的执行结果合并成大任务的结果
        int result = 0;
        for (RecursiveTask<Integer> subTask : subTasks) {
            result += subTask.join();
        }
        return result;
    }
};

// 提交大任务到分治线程池执行
Integer result = forkJoinPool.invoke(task);

// 手动关闭线程池
forkJoinPool.shutdown();

总结提升

1. FixedThreadPool（有限线程数的线程池）：线程数是固定的，一旦线程池的大小达到了最大值，新的任务会被放入阻塞队列中等待。适用于需要限制线程数的场景，如服务器端并发请求。
2. CachedThreadPool（无限线程数的线程池）：线程数不限制，适用于执行很多短期异步任务的程序，线程数根据需要自动调整，线程空闲超过60秒则自动回收。
3. ScheduledThreadPool（定时线程池）：可以定时或延时执行任务的线程池。适用于需要延迟执行或定期执行任务的场景。
4. SingleThreadExecutor（单一线程池）：只有一个线程的线程池，所有任务按照指定顺序依次执行。适用于需要顺序执行任务的场景，如保证线程安全、避免竞态条件等。
5. SingleThreadScheduledExecutor（单一定时线程池）：只有一个线程的定时线程池。适用于需要延迟执行或定期执行任务，且只需一个线程的场景。
6. ForkJoinPool（分治线程池）：适用于执行大量并行的、任务可以拆分为子任务的场景，通常用于计算密集型任务。可以自动拆分任务并提交到线程池中，当每个子任务完成后，自动将结果合并。
   不同的线程池有不同的使用场景和特点，可以根据具体需求选择合适的线程池。