Java六种常用线程池

绝地灬酷狼 2023-10-09 15:37 27阅读 0赞

#### Java六种线程池 ####

*  一：六种常用线程池
 *  二：如何进行使用
 *   *  2.1FixedThreadPool（有限线程数的线程池）
     *  2.2CachedThreadPool（无限线程数的线程池）
     *  2.3 ScheduledThreadPool（定时线程池）
     *  2.4 SingleThreadExecutor（单一线程池）
     *  2.5 SingleThreadScheduledExecutor（单一定时线程池）
     *  2.6 ForkJoinPool（分治线程池）
 *  总结提升

## 一：六种常用线程池 ##

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

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

## 二：如何进行使用 ##

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

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

**如何使用**

1.  实例化线程池对象

ExecutorService executorService = Executors.newFixedThreadPool(60);

1.  创建任务

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

1.  提交任务

executorService.submit(new PrintTask());

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

executorService.shutdown();

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

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

1.  实例化线程池对象

ExecutorService executorService = Executors.newCachedThreadPool();

1.  创建任务

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

1.  提交任务

executorService.submit(new PrintTask());

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

executorService.shutdown();

### 2.3 ScheduledThreadPool（定时线程池） ###

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

1.  实例化线程池对象

ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);

1.  创建任务

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

1.  提交任务

// 延迟执行任务
    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（分治线程池）：适用于执行大量并行的、任务可以拆分为子任务的场景，通常用于计算密集型任务。可以自动拆分任务并提交到线程池中，当每个子任务完成后，自动将结果合并。  
    不同的线程池有不同的使用场景和特点，可以根据具体需求选择合适的线程池。