ExecutorService 的理解与使用

最新推荐文章于 2025-07-17 11:45:29 发布
转载 最新推荐文章于 2025-07-17 11:45:29 发布 · 2.2k 阅读 · 3

ExecutorService用法详解

接口 java.util.concurrent.ExecutorService 表述了异步执行的机制，并且可以让任务在后台执行。壹個 ExecutorService 实例因此特别像壹個线程池。事实上，在 java.util.concurrent 包中的ExecutorService 的实现就是壹個线程池的实现。

ExecutorService 样例

这里有壹個简单的使用Java 实现的 ExectorService 样例：

ExecutorService executorService= Executors.newFixedThreadPool(10);

 

executorService.execute(newRunnable() {

    public void run() {

        System.out.println("Asynchronoustask");

    }

});

 

executorService.shutdown();

 

首先使用newFixedThreadPool() 工厂方法创建壹個ExecutorService ，上述代码创建了壹個可以容纳10個线程任务的线程池。其次，向 execute() 方法中传递壹個异步的Runnable 接口的实现，这样做会让ExecutorService 中的某個线程执行这個 Runnable 线程。

任务的委托（Task Delegation）

下方展示了一个线程的把任务委托异步执行的ExecutorService的示意图。

壹旦线程把任务委托给ExecutorService，该线程就会继续执行与运行任务无关的其它任务。

ExecutorService 的实现

由于 ExecutorService 只是壹個接口，你壹量需要使用它，那麽就需要提供壹個该接口的实现。ExecutorService 接口在java.util.concurrent 包中有如下实现类：

ThreadPoolExecutor

ScheduledThreadPoolExecutor

创建壹個 ExecutorService

你可以根据自己的需要来创建壹個ExecutorService ，也可以使用 Executors 工厂方法来创建壹個 ExecutorService 实例。这里有几個创建ExecutorService 的例子：

ExecutorServiceexecutorService1 = Executors.newSingleThreadExecutor();

ExecutorServiceexecutorService2 = Executors.newFixedThreadPool(10);

ExecutorServiceexecutorService3 = Executors.newScheduledThreadPool(10);

ExecutorService 使用方法

这里有几种不同的方式让你将任务委托给壹個ExecutorService：

execute(Runnable)

submit(Runnable)

submit(Callable)

invokeAny(...)

invokeAll(...)

我会在接下来的内容里把每個方法都看壹遍。

execute(Runnable)

方法 execute(Runnable) 接收壹個 java.lang.Runnable 对象作为参数，并且以异步的方式执行它。如下是壹個使用 ExecutorService 执行 Runnable 的例子：

 

ExecutorServiceexecutorService = Executors.newSingleThreadExecutor();

 

executorService.execute(newRunnable() {

    public void run() {

        System.out.println("Asynchronoustask");

    }

});

 

executorService.shutdown();

 

使用这种方式没有办法获取执行 Runnable 之后的结果，如果你希望获取运行之后的返回值，就必须使用接收 Callable 参数的 execute() 方法，后者将会在下文中提到。

submit(Runnable)

方法 submit(Runnable) 同样接收壹個 Runnable 的实现作为参数，但是会返回壹個Future 对象。这個 Future 对象可以用于判断 Runnable 是否结束执行。如下是壹個ExecutorService 的 submit() 方法的例子：

 

Future future =executorService.submit(new Runnable() {

    public void run() {

        System.out.println("Asynchronoustask");

    }

});

//如果任务结束执行则返回 null

System.out.println("future.get()="+ future.get());

submit(Callable)

方法 submit(Callable) 和方法 submit(Runnable) 比较类似，但是区别则在于它们接收不同的参数类型。Callable 的实例与 Runnable 的实例很类似，但是 Callable 的 call() 方法可以返回壹個结果。方法 Runnable.run() 则不能返回结果。

 

Callable 的返回值可以从方法 submit(Callable) 返回的 Future 对象中获取。如下是壹個 ExecutorService Callable 的样例：

 

Future future =executorService.submit(new Callable(){

    public Object call() throws Exception {

        System.out.println("AsynchronousCallable");

        return "Callable Result";

    }

});

 

System.out.println("future.get()= " + future.get());

 

上述样例代码会输出如下结果：

AsynchronousCallable

future.get() =Callable Result

inVokeAny()

方法 invokeAny() 接收壹個包含 Callable 对象的集合作为参数。调用该方法不会返回 Future 对象，而是返回集合中某壹個 Callable对象的结果，而且无法保证调用之后返回的结果是哪壹個 Callable，只知道它是这些Callable 中壹個执行结束的 Callable 对象。

 

如果壹個任务运行完毕或者抛出异常，方法会取消其它的 Callable 的执行。

 

以下是壹個样例：

ExecutorServiceexecutorService = Executors.newSingleThreadExecutor();

 

Set<Callable<String>>callables = new HashSet<Callable<String>>();

 

callables.add(newCallable<String>() {

    public String call() throws Exception {

        return "Task 1";

    }

});

callables.add(newCallable<String>() {

    public String call() throws Exception {

        return "Task 2";

    }

});

callables.add(newCallable<String>() {

    public String call() throws Exception {

        return "Task 3";

    }

});

 

String result =executorService.invokeAny(callables);

 

System.out.println("result= " + result);

 

executorService.shutdown();

 

以上样例代码会打印出在给定的集合中的某壹個Callable 的返回结果。我尝试运行了几次，结果都在改变。有时候返回结果是"Task 1"，有时候是"Task2"，等等。

invokeAll()

方法 invokeAll() 会调用存在于参数集合中的所有 Callable 对象，并且返回包含所有Future对象的集合，你可以通过这個返回的集合来管理每個 Callable 的执行结果。

 

需要注意的是，任务有可能因为异常而导致运行结束，所以它可能并不是真的成功运行了。但是我们没有办法通过 Future 对象来了解到这個差异。

 

以下是壹個代码样例：

ExecutorServiceexecutorService = Executors.newSingleThreadExecutor();

 

Set<Callable<String>>callables = new HashSet<Callable<String>>();

 

callables.add(newCallable<String>() {

    public String call() throws Exception {

        return "Task 1";

    }

});

callables.add(newCallable<String>() {

    public String call() throws Exception {

        return "Task 2";

    }

});

callables.add(newCallable<String>() {

    public String call() throws Exception {

        return "Task 3";

    }

});

 

List<Future<String>>futures = executorService.invokeAll(callables);

 

for(Future<String>future : futures){

    System.out.println("future.get =" + future.get());

}

 

executorService.shutdown();

ExecuteService 服务的关闭

当使用 ExecutorService 完毕之后，我们应该关闭它，这样才能保证线程不会继续保持运行状态。

 

举例来说，如果你的程序通过 main() 方法启动，并且主线程退出了你的程序，如果你还有壹個活动的 ExecutorService 存在于你的程序中，那么程序将会继续保持运行状态。存在于 ExecutorService 中的活动线程会阻止Java虚拟机关闭。

 

为了关闭在 ExecutorService 中的线程，你需要调用 shutdown() 方法。

 

ExecutorService 并不会马上关闭，而是不再接收新的任务，壹但所有的线程结束执行当前任务，ExecutorServie 才会真的关闭。所有在调用shutdown() 方法之前提交到 ExecutorService 的任务都会执行。

 

如果你希望立即关闭ExecutorService，你可以调用 shutdownNow() 方法。这個方法会尝试马上关闭所有正在执行的任务，并且跳过所有已经提交但是还没有运行的任务。但是对于正在执行的任务，是否能够成功关闭它是无法保证的，有可能他们真的被关闭掉了，也有可能它会壹直执行到任务结束。这是壹個最好的尝试。

shutdown()和shutdownNow()的区别

shutdown()：执行后不再接收新任务，如果里面有任务，就执行完；通常shutdown之后调用awaitTermination(long timeout,TimeUnit unit)，作用是：后者会阻塞当前线程，等待剩余任务执行完，然后继续往下执行。如果不适用await，那么shutdown之后，很可能导致剩余任务得不到执行（整个程序退出），或是执行出现异常（某些资源被释放之类）。

 

shutdownNow()：执行后不再接受新任务，如果有等待任务，移出队列；有正在执行的，尝试停止之；

 

示例1：

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutorService;  

import java.util.concurrent.Executors;  

import java.util.concurrent.Future;

 

public  class  CallableAndFuture {  

 

    /**

     * 自定义一个任务类,实现Callable接口 

     */ 

    public staticclass MyCallableClass implements Callable{  

        // 标志位  

        private intflag = 0;  

        publicMyCallableClass(int flag){  

           this.flag = flag;  

        }  

        publicString call() throws Exception{  

            if(this.flag == 0){

                // 如果flag的值为0,则立即返回  

               return "flag = 0";  

            }   

            if(this.flag == 1){

                // 如果flag的值为1,做一个无限循环  

                try{  

                   while (true) {  

                       System.out.println("looping.");  

                       Thread.sleep(2000);  

                   }  

                }catch (InterruptedException e) {  

                   System.out.println("Interrupted");  

               }  

               return "false";  

            } else{  

                //falg不为0或者1,则抛出异常  

               throw new Exception("Bad flag value!");  

            }  

        }  

    }  

      

    public staticvoid main(String[] args) {  

        // 定义3个Callable类型的任务  

       MyCallableClass task1 = new MyCallableClass(0);  

       MyCallableClass task2 = new MyCallableClass(1);  

       MyCallableClass task3 = new MyCallableClass(2);  

          

        // 创建一个执行任务的服务  

       ExecutorService es = Executors.newFixedThreadPool(3);   

        try {  

            // 提交并执行任务,任务启动时返回了一个 Future对象,  

            // 如果想得到任务执行的结果或者是异常可对这个Future对象进行操作  

            Futurefuture1 = es.submit(task1);  

            // 获得第一个任务的结果,如果调用get方法,当前线程会等待任务执行完毕后才往下执行  

           System.out.println("task1: " + future1.get());  

              

            Futurefuture2 = es.submit(task2);  

            // 等待5秒后,再停止第二个任务。因为第二个任务进行的是无限循环  

           Thread.sleep(5000);  

           System.out.println("task2 cancel: " + future2.cancel(true));   

              

            // 获取第三个任务的输出,因为执行第三个任务会引起异常  

            // 所以下面的语句将引起异常的抛出  

            Futurefuture3 = es.submit(task3);  

           System.out.println("task3: " + future3.get());  

        } catch(Exception e){  

            System.out.println(e.toString());  

        }  

        // 停止任务执行服务  

       es.shutdownNow();  

    }  

}

示例2：

下列方法分两个阶段关闭 ExecutorService。第一阶段调用 shutdown 拒绝传入任务，然后调用 shutdownNow（如有必要）取消所有遗留的任务： 

voidshutdownAndAwaitTermination(ExecutorService pool) {

  pool.shutdown(); // Disable new tasks from being submitted

  try {

    // Wait a while for existing tasks to terminate

    if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {

      pool.shutdownNow(); // Cancel currently executing tasks

      // Wait a while for tasks to respond to being cancelled

      if (!pool.awaitTermination(60, TimeUnit.SECONDS))

           System.err.println("Pool didnot terminate");

    }

  } catch (InterruptedException ie) {

    // (Re-)Cancel if current thread also interrupted

    pool.shutdownNow();

    // Preserve interrupt status

    Thread.currentThread().interrupt();

  }

 }

 

void shutdownAndAwaitTermination(ExecutorService pool) {  

  pool.shutdown(); // Disable new tasks from being submitted  

  try {  

    // Wait a while for existing tasks to terminate  

    if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {  

      pool.shutdownNow(); // Cancel currently executing tasks  

      // Wait a while for tasks to respond to being cancelled  

      if (!pool.awaitTermination(60, TimeUnit.SECONDS))  

          System.err.println("Pool did not terminate");  

    }  

  } catch (InterruptedException ie) {  

    // (Re-)Cancel if current thread also interrupted  

    pool.shutdownNow();  

    // Preserve interrupt status  

    Thread.currentThread().interrupt();  

  }  

}  

 

ExecuteService 服务的关闭

当使用 ExecutorService 完毕之后，我们应该关闭它，这样才能保证线程不会继续保持运行状态。 
举例来说，如果你的程序通过 main() 方法启动，并且主线程退出了你的程序，如果你还有壹個活动的 ExecutorService 存在于你的程序中，那么程序将会继续保持运行状态。存在于 ExecutorService 中的活动线程会阻止Java虚拟机关闭。 
为了关闭在 ExecutorService 中的线程，你需要调用 shutdown() 方法。ExecutorService 并不会马上关闭，而是不再接收新的任务，壹但所有的线程结束执行当前任务，ExecutorServie 才会真的关闭。所有在调用 shutdown() 方法之前提交到 ExecutorService 的任务都会执行。 
如果你希望立即关闭 ExecutorService，你可以调用 shutdownNow() 方法。这個方法会尝试马上关闭所有正在执行的任务，并且跳过所有已经提交但是还没有运行的任务。但是对于正在执行的任务，是否能够成功关闭它是无法保证的，有可能他们真的被关闭掉了，也有可能它会壹直执行到任务结束。这是壹個最好的尝试。 

本文英文原文链接：http://tutorials.jenkov.com/java-util-concurrent/executorservice.html#executorservice-example ，中文译文首发开源中国社区 http://my.oschina.net/bairrfhoinn/blog/177639，转载请注明原始出处。


并发编程(五)-ExecutorService源码分析
流星1688
03-23 1330
ExecutorService 是 Java 中的一个接口，它扩展了 Executor 接口，并提供了更多的方法来处理多线程任务。它是 Java 中用于执行多线程任务的框架之一，可以创建一个线程池，将多个任务提交到线程池中执行。ExecutorService 接口提供了许多方法，如 shutdown()、shutdownNow()、submit()、execute()、invokeAll() 等，可以更方便地提交任务、执行任务、关闭线程池等操作。
Java零基础-线程池（`ExecutorService`）的使用
喵手的博客
08-31 817
在上一期中，我们深入探讨了Java多线程编程的基本概念、实现方法以及线程同步的相关技术，帮助你理解了如何通过多线程来提升程序的性能和响应能力。然而，在实际开发中，频繁创建和销毁线程会带来额外的资源开销，并可能导致系统性能下降。为了解决这一问题，本期我们将聚焦于Java中的线程池机制，介绍的使用方法，帮助你有效管理线程，优化多线程编程的性能。本文将详细介绍Java线程池的概念、接口及其实现类的使用方法，以及线程池的创建与配置。
Java ExecutorService四种线程池使用详解
08-28
主要介绍了Java ExecutorService四种线程池使用详解，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
ExecutorService用法详解.doc
09-14
接口 java.util.concurrent.ExecutorService 表述了异步执行的机制，并且可以让任务在后台执行。壹個 ExecutorService 实例因此特别像壹個线程池。事实上，在 java.util.concurrent 包中的 ExecutorService 的实现就是壹個线程池的实现。
正确理解ExecutorService.shutdown()的优雅关闭行为
最新发布
weixin_29840475的博客
07-17 757
在Java并发编程中，Future接口是用于表示异步计算的结果的一种方式。它使得我们可以提交一个任务到线程池中执行，并在稍后获得任务的执行结果，而不需要阻塞当前线程等待结果的返回。Future接口包含以下几个核心方法：get()：等待计算完成，并获取结果。如果任务还没有完成，则当前线程会一直等待，直到任务执行完毕。：与get()类似，但增加了超时设置，超时则抛出。：取消任务的执行。如果任务已经开始执行，根据参数决定是否中断正在执行的线程。isDone()
java ExecutorService使用方法详解
09-01
主要为大家详细介绍了java ExecutorService使用方法,具有一定的参考价值，感兴趣的小伙伴们可以参考一下
ExecutorService(任务调度器)详解
深入一点
04-06 1216
前言:这是一次艰苦的旅行... 一.ExecutorService: 它也是一个接口，它扩展自Executor接口，Executor接口更像一个抽象的命令模式，仅有一个方法:execute(runnable);Executor接口简单，但是很重要，重要在这种设计的模式上。。   ExecutorService在Executor的基础上增加了“service”特性的方法： shutd...
理解java多线程中ExecutorService使用
09-01
在Java多线程编程中，`ExecutorService`是核心组件之一，它位于`java.util.concurrent`包下，为线程的管理和执行提供了便利。...理解并熟练使用这些组件，可以更好地优化多线程程序的性能和资源利用率。
multithread:使用 Java8 ExecutorService 的简单多线程示例
06-06
在Java编程中，多线程是并发编程的重要组成部分，它允许程序同时执行多个任务，从而提高了应用程序的...通过学习这些示例，你可以更深入地理解如何在实际项目中有效地使用 Java 8 的 ExecutorService 进行多线程编程。
并发工具类：ExecutorService、Future、CountDownLatch与Semaphore（第一章）
m0_61635718的博客
04-04 1339
在当今多核处理器普及的背景下，多线程编程已成为提升软件性能、充分利用硬件资源的关键手段。然而，多线程编程也伴随着一系列复杂问题，如线程同步、资源争抢、死锁等，这些问题若处理不当，将严重影响程序的正确性和稳定性。为此，Java平台通过其强大的并发工具类库为开发者提供了高效且易于使用的解决方案，其中ExecutorService、Future、CountDownLatch与Semaphore尤为突出，它们在Java多线程编程中扮演着至关重要的角色。
java并发中ExecutorService的使用
热门推荐
程序那些事
03-10 1万+
文章目录创建ExecutorService为ExecutorService分配Tasks关闭ExecutorServiceFutureScheduledExecutorServiceExecutorService和 Fork/Join java并发中ExecutorService的使用 ExecutorService是java中的一个异步执行的框架，通过使用ExecutorService可以方便的...
Android线程——使用ExecutorService类来实现线程的管理
weixin_34148508的博客
10-27 268
个人博客CoorChice，https://chenbingx.github.io/ ，最新文章将会首发CoorChice的博客，欢迎探索哦 ! 同时，搜索微信公众号CoorChice，或扫描文章末尾二维码，可以关注我的微信公众号。同期文章也将会优先推送到微信公众号中，以提醒您有新鲜文章出炉。 在Jav...
ExecutorService
qq_39158142的博客
02-14 1796
ExecutorService 即线程池。   1 submit  提交一个返回值的任务用于执行，返回一个表示任务的未决结果的 Future 2 shutdown  启动一次顺序关闭，执行以前提交的任务，但不接受新任务. 3 shutdownNow 试图停止所有正在执行的活动任务，暂停处理正在等待的任务，并返回等待执行的任务列表 4 isShutdown 如果此执行程序已关闭，...
ExecutorService 的理解和使用
a18827547638的博客
11-16 1624
前言： 我们之前使用线程的时候都是使用new Thread来进行线程的创建，但是这样会有一些问题。如： a. 每次new Thread新建对象性能差。 b. 线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。 c. 缺乏更多功能，如定时执行、定期执行、线程中断。 相比new Thread，Java提供的四种线程池的好处在于： a. 重用存在的线程，减少对象创建、消亡的开销，性能佳。 b. 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免
ExecutorService 的使用
屋顶小黑猫
02-06 1148
摘要：ExecutorService是Java并发编程中的重要接口，但使用不当会导致严重问题。Executors提供的四种线程池(newSingleThreadExecutor、newCachedThreadPool、newFixedThreadPool、newScheduledThreadPool)在默认配置下存在OOM风险。特别需要注意的是，线程池不会随main方法结束自动关闭，必须手动调用shutdown()方法，并配合awaitTermination()设置超时时间，最后用shutdownNow()
关于ExecutorService的使用
种田好累
09-11 226
ExecutorService： 线程池， 顾名思义是一个调度线程运行的管理池。 我预制了一个场景： 在界面上，有5个图片需要进行异步加载， 我们使用了一个线程池管理类 AsyncImageLoader来控制加载图片的线程个数，如果加载的图片原本已经存在，则从系统中调出已有图片进行加载； 如果图片是首次加载，则通过连接加载图片。 1. 需要加载5个图片的界面： [code="xml"] ...
JUC：ExecutorService使用
qq_37113604的博客
04-19 357
new Thread的弊端： new Thread(new Runnable() { @Override public void run() { // TODO Auto-generated method stub } }).start(); 1.线程的创建和释放，需要占用不小的内存和资源，每次new Thread新建对象性能差。 2.线程缺乏统一...
executorservice使用
04-28
<think>好的，用户想了解如何使用ExecutorService，需要方法指南和代码示例。首先，我需要整理ExecutorService的基本概念和主要功能。根据引用内容，ExecutorService是Java中管理线程池的接口，可以通过Executors工厂类创建不同类型的线程池，比如单线程、固定大小线程池和可调度线程池。用户可能需要知道如何创建实例、提交任务以及关闭服务。 接下来，要分步骤说明使用方法。第一步是创建实例，引用1和2提供了三种创建方式：newSingleThreadExecutor、newFixedThreadPool和newScheduledThreadPool。需要详细解释每种线程池的特点，比如单线程适用于顺序执行，固定大小适合并发任务，可调度用于定时任务。 第二步是提交任务。引用3中的示例展示了使用execute方法提交Runnable任务，而引用4则提到使用submit或invokeAll处理Callable任务。需要区分这两种任务类型，Runnable没有返回值，Callable可以返回结果。需要给出代码示例，比如如何提交多个任务并获取Future对象。 第三步是关闭ExecutorService，这点在引用4的finally块中有提到shutdown方法。需要强调正确关闭的重要性，避免资源泄漏。可能还要介绍shutdownNow的强制关闭方法，但需要注意未完成任务的处理。 然后，提供完整的代码示例。结合引用3和4，可以展示一个使用固定线程池处理多个任务的例子，包括创建线程池、提交任务、处理结果和关闭服务。同时，可以加入Callable的示例，说明如何获取任务返回值，如引用4中的invokeAll和Future的使用。 另外，需要提醒用户注意异常处理和资源释放，确保线程池在不再使用时被正确关闭。可能还需要提到线程池的配置参数，比如核心线程数、最大线程数等，但用户的问题可能更关注基础使用，所以这部分可以简要带过或放在相关问题中。 最后，生成相关问题，帮助用户深入理解，比如如何选择线程池类型、处理任务返回值、配置参数等。这些需要基于现有引用内容扩展，确保问题相关且有参考价值。 检查是否所有LaTeX格式正确，但用户的问题不涉及数学公式，可能不需要使用。但根据系统指令，行内表达式需要用$...$，但这里可能用不上，需要注意是否有变量或代码块需要特别标注。不过代码示例已经用代码块格式，所以没问题。 需要确保回答结构清晰，分步骤说明，并包含代码示例。同时引用相关的引用，比如创建线程池的方法在引用1和2中提到，任务提交在引用3和4中，关闭服务在引用4。在适当的位置添加引用标识，如创建实例时引用[^1][^2]，提交任务时引用[^3][^4]。</think>以下是为您整理的ExecutorService使用方法及代码示例： ### 一、ExecutorService核心用法 1. **创建线程池实例** 通过Executors工厂类创建三种典型线程池： ```java // 单线程池（顺序执行任务） ExecutorService executor1 = Executors.newSingleThreadExecutor(); // [^1][^2] // 固定大小线程池（处理突发任务） ExecutorService executor2 = Executors.newFixedThreadPool(10); // [^1][^2] // 可调度线程池（定时/周期任务） ScheduledExecutorService executor3 = Executors.newScheduledThreadPool(10); // [^2] ``` 2. **提交任务** 支持Runnable和Callable两种任务类型： ```java // 提交Runnable任务（无返回值） executor.execute(new Runnable() { @Override public void run() { System.out.println("执行任务"); } }); // [^3] // 提交Callable任务（带返回值） Future<Integer> future = executor.submit(() -> { return 1 + 1; }); ``` 3. **关闭线程池** ```java executor.shutdown(); // 温和关闭（完成已提交任务） executor.shutdownNow(); // 强制关闭（返回未执行任务列表） ``` ### 二、完整代码示例 ```java import java.util.Arrays; import java.util.List; import java.util.concurrent.*; public class ExecutorDemo { public static void main(String[] args) throws Exception { // 创建固定线程池 ExecutorService executor = Executors.newFixedThreadPool(3); // [^3] // 提交多个Callable任务 List<Callable<Integer>> tasks = Arrays.asList( () -> { Thread.sleep(1000); return 1; }, () -> { Thread.sleep(500); return 2; }, () -> { return 3; } ); // 批量执行并获取结果 List<Future<Integer>> futures = executor.invokeAll(tasks); // [^4] for (Future<Integer> f : futures) { System.out.println("结果：" + f.get()); } executor.shutdown(); // [^4] } } ``` ### 三、关键特性说明 | 方法 | 说明 | 适用场景 | |-------------------------|------------------------------------|----------------------| | newSingleThreadExecutor | 保证任务顺序执行 | 需要严格顺序的场景 | | newFixedThreadPool | 控制最大并发数 | Web服务请求处理 | | newCachedThreadPool | 自动扩容线程池 | 短期异步任务处理 | | newScheduledThreadPool | 支持定时/周期性任务 | 定时数据同步 |
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值