Java中线程池ExecutorService使用方法

ExecutorService是Java中管理异步任务的核心工具，相比直接创建Thread，它通过线程池机制实现线程复用、控制并发数、管理任务队列和统一关闭，提升系统稳定性和资源利用率。

Java中的

ExecutorService

使用

ExecutorService

创建线程池 Java的

Executors

ExecutorService

1. Executors.newFixedThreadPool(int nThreads)

   登录后复制
   : 创建一个固定大小的线程池。当提交的任务多于线程数时，多余的任务会排队等待。这很适合处理CPU密集型任务，或者当你知道系统能承受的最大并发量时。

2. Executors.newCachedThreadPool()

   登录后复制
   : 创建一个可缓存的线程池。如果池中有空闲线程，就复用；如果没有，就创建新线程。空闲时间超过60秒的线程会被回收。这个适用于执行大量短期异步任务的场景，比如I/O密集型任务。

3. Executors.newSingleThreadExecutor()

   登录后复制
   : 创建一个单线程的

   ExecutorService

   登录后复制
   。它能保证所有任务按照提交的顺序串行执行。如果你需要确保任务的执行顺序，且不希望手动同步，这是一个很好的选择。

4. Executors.newScheduledThreadPool(int corePoolSize)

   登录后复制
   : 创建一个支持定时及周期性任务执行的线程池。

除了这些工厂方法，我们也可以直接通过

ThreadPoolExecutor

提交任务

ExecutorService

立即学习“Java免费学习笔记（深入）”；

1. execute(Runnable command)

   登录后复制
   : 提交一个不需要返回结果的任务。

2. submit(Callable<T> task)

   登录后复制
   /

   submit(Runnable task)

   登录后复制
   : 提交一个可能需要返回结果（通过

   Future

   登录后复制
   对象获取）的任务。

   Callable

   登录后复制
   接口允许任务抛出异常并返回一个泛型结果，而

   Runnable

   登录后复制
   的

   submit

   登录后复制
   版本则返回一个代表任务完成的

   Future

   登录后复制
   对象。

关闭线程池 当

ExecutorService

1. shutdown()

   登录后复制
   : 启动有序关闭，不再接受新任务，但会完成已提交的任务。

2. shutdownNow()

   登录后复制
   : 尝试立即停止所有正在执行的任务，并停止处理等待任务，返回未执行的任务列表。

import java.util.concurrent.*;

public class ExecutorServiceExample {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        // 1. 创建一个固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(2);

        // 2. 提交Runnable任务
        executor.execute(() -> {
            System.out.println("Runnable Task 1 running on thread: " + Thread.currentThread().getName());
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            System.out.println("Runnable Task 1 finished.");
        });

        // 3. 提交Callable任务并获取Future
        Future<String> future = executor.submit(() -> {
            System.out.println("Callable Task 2 running on thread: " + Thread.currentThread().getName());
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return "Task 2 interrupted!";
            }
            System.out.println("Callable Task 2 finished.");
            return "Task 2 Result";
        });

        // 4. 获取Callable任务的结果
        System.out.println("Future result: " + future.get()); // get()会阻塞直到任务完成

        // 5. 提交更多任务，看它们如何排队
        executor.execute(() -> {
            System.out.println("Runnable Task 3 running on thread: " + Thread.currentThread().getName());
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            System.out.println("Runnable Task 3 finished.");
        });

        // 6. 关闭线程池
        executor.shutdown(); // 不再接受新任务，但会等待已提交任务完成
        System.out.println("ExecutorService shutdown initiated.");

        // 等待所有任务完成，最多等待5秒
        if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
            System.err.println("ExecutorService did not terminate in the specified time.");
            executor.shutdownNow(); // 尝试立即停止
        }
        System.out.println("All tasks completed or forcefully stopped.");
    }
}

为什么在现代Java应用中，我们更倾向于使用ExecutorService而不是直接创建Thread？

这几乎是一个共识了，直接

new Thread()

想象一下，如果你的应用需要处理成千上万个并发请求，每个请求都

new Thread()

OutOfMemoryError

ExecutorService

Runnable

Callable

ExecutorService

ExecutorService

通过线程池，我们可以：

• 重用线程：避免了频繁创建和销毁线程的开销。
• 控制并发数：可以限制同时运行的线程数量，防止系统过载。
• 管理任务队列：当线程池满时，新任务可以在队列中等待，而不是直接被拒绝或导致系统崩溃。
• 提供高级功能：比如定时任务、获取任务执行结果（

  Future

  登录后复制
  ）、以及统一的关闭机制。

所以，与其说我们“倾向于”使用

ExecutorService

几种常见的ExecutorService线程池类型及其适用场景分析

Executors

ThreadPoolExecutor

1. FixedThreadPool

   登录后复制
   (固定大小线程池)
   • 特点：核心线程数和最大线程数相等，线程数量固定。当任务量超过线程数时，新任务会进入无界队列等待。
   • 适用场景：
     • CPU密集型任务：如果任务主要消耗CPU，那么线程数通常设置为CPU核心数或核心数+1，以最大化CPU利用率，避免过多线程切换带来的开销。
     • 负载可预测的场景：例如，一个后台服务需要持续处理一定量的计算任务，且并发量相对稳定。
   • 我的看法：这是最常用也最“安全”的一种。因为它限制了并发，不会因为任务量暴增而耗尽系统资源。但缺点也很明显，如果任务都是I/O密集型，那么固定线程数可能导致CPU利用率不高，因为线程在等待I/O时无法执行其他任务。

2. CachedThreadPool

   登录后复制
   (可缓存线程池)
   • 特点：核心线程数为0，最大线程数为

     Integer.MAX_VALUE

     登录后复制
     。当有任务提交时，如果池中有空闲线程就复用；如果没有，就创建新线程。空闲线程在一定时间（默认60秒）后会被回收。使用

     SynchronousQueue

     登录后复制
     作为工作队列，这意味着提交任务时必须有可用线程来立即执行，否则会创建新线程。
   • 适用场景：
     • I/O密集型任务：任务执行时间短，但数量可能非常多，且并发量波动大。例如，处理大量的网络请求，每个请求都很快完成，但并发数不确定。
     • 任务生命周期短：线程在任务完成后很快就能被回收或复用。
   • 我的看法：

     CachedThreadPool

     登录后复制
     很“聪明”，它能根据负载动态调整线程数。但它也有潜在的风险：如果任务持续不断且执行时间较长，可能会创建出非常多的线程，最终耗尽系统内存。所以在生产环境中，我通常会更谨慎地使用它，或者限制其最大线程数。

3. SingleThreadExecutor

   登录后复制
   (单线程线程池)
   

   如此AI员工

   国内首个全链路营销获客AI Agent

   172

   查看详情
   • 特点：只有一个工作线程。所有任务都会按提交顺序依次执行。
   • 适用场景：
     • 需要保证任务严格顺序执行的场景：例如，更新某个共享资源，或者处理日志写入，确保不会出现并发问题。
     • 避免手动同步：通过将所有相关操作提交给单线程池，可以天然地避免复杂的锁机制。
   • 我的看法：这个池子在需要“串行化”处理某些逻辑时非常方便，它帮你省去了很多手动加锁、同步的麻烦。但如果任务本身执行很慢，它会成为性能瓶颈。

4. ScheduledThreadPool

   登录后复制
   (定时任务线程池)
   • 特点：支持定时（延迟执行）和周期性任务执行。
   • 适用场景：
     • 周期性数据同步：例如，每隔5分钟同步一次数据。
     • 延迟执行任务：例如，用户下单后30分钟如果未支付则自动取消订单。
     • 后台监控或清理任务。
   • 我的看法：它是处理定时任务的首选，比

     Timer

     登录后复制
     更健壮，因为它能更好地处理任务执行时的异常，并且可以配置多个线程并行执行定时任务。

在实际项目中，很多时候我们最终会发现，

Executors

ThreadPoolExecutor

corePoolSize

maximumPoolSize

keepAliveTime

workQueue

RejectedExecutionHandler

ThreadPoolExecutor

在实际项目中，如何优雅地管理和关闭ExecutorService以避免资源泄露？

在实际项目中，

ExecutorService

ExecutorService

为什么必须关闭？

ExecutorService

main

优雅关闭的策略

1. 调用

   shutdown()

   登录后复制
   ：启动有序关闭 这是最常用的关闭方式。

   shutdown()

   登录后复制
   方法会启动一个有序的关闭序列：
   • 它会拒绝新的任务提交。
   • 但会等待所有已提交的任务执行完毕。
   • 一旦所有任务完成，线程池中的线程就会被终止。

   最佳实践：在你的应用生命周期结束时（例如，Web应用的

   destroy

   登录后复制
   方法、Spring应用的

   @PreDestroy

   登录后复制
   方法，或者命令行应用的

   main

   登录后复制
   方法结束前），调用

   shutdown()

   登录后复制
   。

2. 配合

   awaitTermination()

   登录后复制
   ：等待任务完成 仅仅调用

   shutdown()

   登录后复制
   并不能保证所有任务会立即完成。如果你需要在关闭前确保所有任务都执行完毕（例如，保存最终数据、清理资源），就需要使用

   awaitTermination()

   登录后复制
   。

   awaitTermination(long timeout, TimeUnit unit)

   登录后复制
   会阻塞当前线程，直到所有任务执行完毕，或者超时时间到达，或者当前线程被中断。

   executor.shutdown(); // 启动关闭
   try {
       // 最多等待60秒，看所有任务是否完成
       if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
           // 如果超时了，但任务还没完成，可以考虑强制关闭
           executor.shutdownNow();
           // 再次等待，给强制关闭一个机会
           if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
               System.err.println("线程池未能完全关闭！");
           }
       }
   } catch (InterruptedException ie) {
       // 当前线程在等待时被中断，强制关闭
       executor.shutdownNow();
       Thread.currentThread().interrupt(); // 重新设置中断状态
   }

   登录后复制

   这种模式兼顾了优雅和强制，是生产环境中推荐的做法。

3. 使用

   shutdownNow()

   登录后复制
   ：立即强制关闭

   shutdownNow()

   登录后复制
   会尝试立即停止所有正在执行的任务，并停止处理等待队列中的任务，同时返回一个尚未执行的任务列表。
   • 它会中断正在执行的线程（如果线程响应中断）。
   • 队列中的任务不会被执行。

   适用场景：当系统遇到紧急情况，需要快速释放资源，或者在

   awaitTermination()

   登录后复制
   超时后仍有未完成任务时。

   注意事项：

   shutdownNow()

   登录后复制
   是“尽力而为”的，它依赖于任务代码对中断信号的响应。如果你的任务代码中没有处理

   InterruptedException

   登录后复制
   ，或者执行的是不可中断的I/O操作，那么线程可能不会立即停止。

4. 结合资源管理（

   try-finally

   登录后复制
   或

   try-with-resources

   登录后复制
   ） 如果你的

   ExecutorService

   登录后复制
   生命周期是局部的，例如只在一个方法内部使用，那么可以考虑使用

   try-finally

   登录后复制
   块来确保其关闭：

   ExecutorService executor = Executors.newFixedThreadPool(2);
   try {
       // 提交任务...
   } finally {
       executor.shutdown();
       // 建议加上awaitTermination()
   }

   登录后复制

   对于Java 7+，如果

   ExecutorService

   登录后复制
   实现了

   AutoCloseable

   登录后复制
   接口（虽然标准库的

   ExecutorService

   登录后复制
   没有直接实现，但你可以包装它），则可以使用

   try-with-resources

   登录后复制
   。

5. JVM关闭钩子（Shutdown Hook） 对于应用级别的、贯穿整个生命周期的

   ExecutorService

   登录后复制
   ，可以注册一个JVM关闭钩子，确保在JVM退出前执行关闭逻辑。

   final ExecutorService executor = Executors.newFixedThreadPool(5);
   // ... 提交任务 ...
   
   Runtime.getRuntime().addShutdownHook(new Thread(() -> {
       System.out.println("JVM shutdown hook activated. Shutting down ExecutorService...");
       executor.shutdown();
       try {
           if (!executor.awaitTermination(30, TimeUnit.SECONDS)) {
               System.err.println("ExecutorService did not terminate gracefully, forcing shutdown.");
               executor.shutdownNow();
           }
       } catch (InterruptedException e) {
           Thread.currentThread().interrupt();
           executor.shutdownNow();
       }
       System.out.println("ExecutorService shutdown complete.");
   }));

   登录后复制

   这种方式可以捕获到JVM的正常退出信号（例如，通过Ctrl+C），从而执行清理工作。

总结 正确关闭

ExecutorService

以上就是Java中线程池ExecutorService使用方法的详细内容，更多请关注php中文网其它相关文章！