Java异步编排结合线程池实现多任务按需执行案例

最新推荐文章于 2024-07-19 10:15:52 发布
最新推荐文章于 2024-07-19 10:15:52 发布
阅读量983 收藏 8
点赞数 3
分类专栏： JAVA 文章标签： java 多线程 线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yprufeng/article/details/116639972
版权

前言

在项目中经常会有这样一种场景，在同一个业务中，我们的业务流程会有多个执行步骤，我们最终会把这些业务流程的执行步骤处理结果进行综合处理后返回一个最终结果给前端。按照正常的程序流程串行化执行，可能响应的时间会很长，导致用户体验变差。例如我们在一个业务处理流程中，有5个处理步骤，平均每个处理步骤大概需要1秒钟，那么整个串行化执行过程保守需要5秒钟才能执行完毕，这样加上中间过程处理，可能最终的响应时间远远大于5秒钟，在某些应用场景下，这样的响应效果用户往往是难以接受的。然而真实的情况是我们的整个业务流程处理步骤中，可能只有某些步骤是依赖上一个步骤的处理结果，而其它的步骤是可以并行执行的，串行化执行会导致程序执行过程的阻塞，一步一步执行流程，而并行的方式却可以避免这样的情况，提高程序的执行效率，更快的响应客户的交互需求。在实际的解决方案中我们可以通过闭锁CountDownLatch来解决并行执行的过程，但是CountDownLatch闭锁无法解决部分串行化执行的问题，在java8中，有一种更加合理的多任务处理方案，就是我们的异步编排，可以根据实际执行情况执行我们的程序，不用全部过程阻塞等待。它的核心思想就是短板理论，最终程序的执行时间取决于并行执行业务流程中最后执行完业务的那个执行步骤所花费的时间，如果我们不关心最终的执行结果，那么也可以异步执行直接返回，业务不需要阻塞，从而提高程序执行效率。

正文

  • 创建线程池

说明：创建线程的方式主要有四种，分别是①继承Thread类实现②实现Runnable接口③实现Callable接口④Executor 的工具类创建线程池或者手动创建线程池，本案例我们采用第四种方案，根据实际需求创建线程池。

①配置线程池相关配置

atp:
  thread:
    pool:
      #核心线程数量
      corePoolSize: 20
      #最大线程数
      maximumPoolSize: 200
      #空闲线程的最长时间
      keepAliveTime: 10
      #缓存队列大小
      queueSize: 100000

②加载配置文件数据

package com.yundi.atp.platform.config;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * @Author: yanp
 * @Description: 线程池配置参数
 * @Date: 2021/5/13 11:03
 * @Version: 1.0.0
 */
@Component
@ConfigurationProperties(prefix = "atp.thread.pool")
@Data
public class ThreadPoolConfigProperties {
    /**
     * 核心线程数量
     */
    private Integer corePoolSize;
    /**
     * 最大线程数
     */
    private Integer maximumPoolSize;
    /**
     * 空闲线程的最长时间
     */
    private Integer keepAliveTime;
    /**
     * 队列大小
     */
    private Integer queueSize;
}

③创建线程池实例

package com.yundi.atp.platform.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @Author: yanp
 * @Description: 线程池配置
 * @Date: 2021/5/13 10:38
 * @Version: 1.0.0
 */
@Configuration
public class ThreadPoolConfig {

    @Bean
    public ThreadPoolExecutor threadPoolExecutor(ThreadPoolConfigProperties pool) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(pool.getCorePoolSize(),
                pool.getMaximumPoolSize(),
                pool.getKeepAliveTime(),
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(pool.getQueueSize()),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
        return threadPoolExecutor;
    }

}

  • 异步编排主要API说明

#执行异步操作，有返回值
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)

#执行异步操作，有返回值，并且可以使用自定义线程池
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor)

#执行异步操作，无返回值
public static CompletableFuture<Void> runAsync(Runnable runnable)

#执行异步操作，无返回值，并且可以使用自定义线程池
public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor)

#执行上一个异步操作后新的异步操作，获取上一个任务返回的结果，并返回当前任务的返回值
public <U> CompletableFuture<U> thenApply(Function<? super T,? extends U> fn)

#执行上一个异步操作后新的异步操作，获取上一个任务返回的结果，并返回当前任务的返回值，异步操作
public <U> CompletableFuture<U> thenApplyAsync(Function<? super T,? extends U> fn)

#执行上一个异步操作后新的异步操作，获取上一个任务返回的结果，并返回当前任务的返回值，异步操作加可以自定义线程池
public <U> CompletableFuture<U> thenApplyAsync(Function<? super T,? extends U> fn, Executor executor)

#消费上一个异步操作处理结果。接收上一个异步操作任务的处理结果，并消费处理结果，无返回结果
public CompletableFuture<Void> thenAccept(Consumer<? super T> action)

#消费上一个异步操作处理结果。接收上一个异步操作任务的处理结果，并消费处理结果，无返回结果，异步操作
public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action)

#消费上一个异步操作处理结果。接收上一个异步操作任务的处理结果，并消费处理结果，无返回结果，异步操作，异步操作加可以自定义线程池
public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action, Executor executor)

#上一个异步操作任务执行后的业务操作
public CompletableFuture<Void> thenRun(Runnable action)

#上一个异步操作任务执行后的业务操作，异步操作
public CompletableFuture<Void> thenRunAsync(Runnable action)

#上一个异步操作任务执行后的业务操作，异步操作，异步操作加可以自定义线程池
public CompletableFuture<Void> thenRunAsync(Runnable action, Executor executor)

#任务组合执行
public static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs)

#任意一个任务组合执行完就结束执行
public static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs)
  • 实现异步编排案例

①控制层

package com.yundi.atp.platform.module.sys.controller;

import com.yundi.atp.platform.common.Result;
import com.yundi.atp.platform.module.sys.UserVo;
import com.yundi.atp.platform.module.sys.service.CompletableFutureService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Author: yanp
 * @Description: 异步编排任务测试控制层
 * @Date: 2021/5/13 17:26
 * @Version: 1.0.0
 */
@Api(tags = "异步编排业务测试")
@RestController
@RequestMapping(value = "/completableFuture")
public class CompletableFutureController {
    @Autowired
    private CompletableFutureService completableFutureService;

    @ApiOperation(value = "串行查询用户信息详情")
    @PostMapping(value = "/findUserInfoDescBySerial")
    public Result findUserInfoDescBySerial(@RequestParam(value = "userid") String userid) {
        UserVo userVo = completableFutureService.findUserInfoDescBySerial(userid);
        return Result.success(userVo);
    }

    @ApiOperation(value = "并行查询用户信息详情")
    @PostMapping(value = "/findUserInfoDescByParallel")
    public Result findUserInfoDescByParallel(@RequestParam(value = "userid") String userid) {
        UserVo userVo = completableFutureService.findUserInfoDescByParallel(userid);
        return Result.success(userVo);
    }
}

②业务层

package com.yundi.atp.platform.module.sys.service.impl;

import com.yundi.atp.platform.module.sys.UserVo;
import com.yundi.atp.platform.module.sys.entity.User;
import com.yundi.atp.platform.module.sys.service.CompletableFutureService;
import com.yundi.atp.platform.module.sys.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * @Author: yanp
 * @Description:异步编排测试接口实现类
 * @Date: 2021/5/13 17:41
 * @Version: 1.0.0
 */
@Slf4j
@Service
public class CompletableFutureServiceImpl implements CompletableFutureService {
    @Autowired
    private ThreadPoolExecutor threadPoolExecutor;
    @Autowired
    private UserService userService;

    @Override
    public UserVo findUserInfoDescBySerial(String userid) {
        LocalDateTime startTime = LocalDateTime.now();
        UserVo userVo = new UserVo();
        //1.查询用户信息
        User user = userService.getById(userid);
        BeanUtils.copyProperties(user, userVo);
        //2.业务1结果处理
        String businessOneResult = getBusinessOneResult();
        userVo.setBusinessOne(businessOneResult);
        //3.业务2结果处理
        Integer businessTwoResult = getBusinessTwoResult();
        userVo.setBusinessTwo(businessTwoResult);
        //4.业务3结果处理,基于结果2
        Integer businessThreeResult = getBusinessThreeResult(businessTwoResult);
        userVo.setBusinessThree(businessThreeResult);
        //5.业务4结果处理,基于结果2
        Integer businessFourResult = getBusinessFourResult(businessTwoResult);
        userVo.setBusinessFour(businessFourResult);
        //6.业务5结果处理,基于结果2
        Integer businessFiveResult = getBusinessFiveResult(businessTwoResult);
        userVo.setBusinessFive(businessFiveResult);

        LocalDateTime endTime = LocalDateTime.now();
        log.info("============Serial total execute time:{}s================", ChronoUnit.SECONDS.between(startTime, endTime));
        return userVo;
    }

    @Override
    public UserVo findUserInfoDescByParallel(String userid) {
        LocalDateTime startTime = LocalDateTime.now();
        UserVo userVo = new UserVo();
        //1.查询用户信息
        CompletableFuture<Void> userCompletableFuture = CompletableFuture.runAsync(() -> {
            User user = userService.getById(userid);
            BeanUtils.copyProperties(user, userVo);
        }, threadPoolExecutor);
        //2.业务1结果处理
        CompletableFuture<Void> businessOneCompletableFuture = CompletableFuture.runAsync(() -> {
            String businessOneResult = getBusinessOneResult();
            userVo.setBusinessOne(businessOneResult);
        }, threadPoolExecutor);
        //3.业务2结果处理
        CompletableFuture<Integer> businessTwoCompletableFuture = CompletableFuture.supplyAsync(() -> {
            Integer businessTwoResult = getBusinessTwoResult();
            userVo.setBusinessTwo(businessTwoResult);
            return businessTwoResult;
        }, threadPoolExecutor);
        //4.业务3结果处理,基于结果2
        CompletableFuture<Void> businessThreeCompletableFuture = businessTwoCompletableFuture.thenAcceptAsync(businessTwoResult -> {
            Integer businessThreeResult = getBusinessThreeResult(businessTwoResult);
            userVo.setBusinessThree(businessThreeResult);
        }, threadPoolExecutor);
        //5.业务4结果处理,基于结果2
        CompletableFuture<Void> businessFourResultCompletableFuture = businessTwoCompletableFuture.thenAcceptAsync(businessTwoResult -> {
            Integer businessFourResult = getBusinessFourResult(businessTwoResult);
            userVo.setBusinessFour(businessFourResult);
        }, threadPoolExecutor);
        //6.业务5结果处理,基于结果2
        CompletableFuture<Void> businessFiveResultCompletableFuture = businessTwoCompletableFuture.thenAcceptAsync(businessTwoResult -> {
            Integer businessFiveResult = getBusinessFiveResult(businessTwoResult);
            userVo.setBusinessFive(businessFiveResult);
        }, threadPoolExecutor);
        //7.多任务组合执行
        CompletableFuture.allOf(userCompletableFuture,
                businessOneCompletableFuture,
                businessTwoCompletableFuture,
                businessThreeCompletableFuture,
                businessFourResultCompletableFuture,
                businessFiveResultCompletableFuture).join();
        LocalDateTime endTime = LocalDateTime.now();
        log.info("============Parallel total execute time:{}s================", ChronoUnit.SECONDS.between(startTime, endTime));
        return userVo;
    }

    private Integer getBusinessFiveResult(Integer businessTwoResult) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return businessTwoResult + 20;
    }

    private Integer getBusinessFourResult(Integer businessTwoResult) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return businessTwoResult + 10;
    }

    private Integer getBusinessThreeResult(Integer businessTwoResult) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return businessTwoResult + 5;
    }

    private Integer getBusinessTwoResult() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return 5;
    }

    private String getBusinessOneResult() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "businessOneCompletableFuture";
    }
}

  • 验证

①串行执行结果：能够正确返回结果，根据打印日志，需要5秒钟响应结果

②并行执行结果：能够正确返回结果，根据打印日志，需要2秒钟响应结果

③通过串行化执行与java异步编排的比较，我们发现异步编排能够极大的提升程序的执行效率，尤其是在我们的多个业务执行逻辑互不干涉的场景中，我们可根据需要对我们的业务做合理的异步编排执行。

结语

ok，到这里我们的异步编排案例实战就结束了，下期见。。。

厉害哥哥吖
关注
  • 3
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
专栏目录
多线程 - Thread 使用、线程状态、 CompletableFuture 异步编排
CYK_byte的博客
04-27 1159
Ps：创建线程的时候，给线程起个名字还是很有必要的，目的就是为了方便程序员调试，一旦出问题，方便找到对应的代码，如果不手动起名，JVM 默认会起名为 thread-0、thread-1......操作系统管理这些线程的 PCB 的时候，是有多个链表的，调用了sleep ，就会把 PCB 移动另外一个“阻塞队列”（原先在“就绪队列”），当 sleep 时间到了 ，就会被移动到之前的就绪队列。Ps：直接调用 run 并不会创建线程，只是运行线程中的代码，调用 start 方法，才是创建了线程。
Java 使用线程池执行多个任务的示例
p1830095583的博客
03-12 5280
这篇文章主要介绍了Java 使用线程池执行多个任务的示例，帮助大家更好的理解和学习使用Java，感兴趣的朋友可以了解下 在执行一系列带有IO操作（例如下载文件），且互不相关的异步任务时，采用多线程可以很极大的提高运行效率。线程池包含了一系列的线程，并且可以管理这些线程。例如：创建线程，销毁线程等。本文将介绍如何使用Java中的线程池执行任务。 1 任务类型 在使用线程池执行任务之前，我们弄清楚什么任务可以被线程池调用。按照任务是否有返回值可以将任务分为两种，分别是实现Runnable的任务类（无参数无返回值
java 启动线程 异步_同时工作，Java运行中的线程策略——并发教程
weixin_34320235的博客
02-16 249
并发一、什么是并发？并发是并行运行多个程序或程序的多个部分的能力。如果可以异步或并行执行耗时的任务，则可以提高吞吐量和程序的交互性。现代计算机在一个CPU中具有多个CPU或多个内核。利用这些多核的能力可能是成功实现大批量应用程序的关键。二、进程与线程一个进程独立运行并与其他进程隔离。它不能直接访问其他进程中的共享数据。进程的资源(例如内存和CPU时间)通过操作系统分配给它。一个线程是所谓的轻量级进...
Java中的编排
最新发布
weixin_46372265的博客
07-19 490
编排是一种协调多个服务或组件来完成复杂任务的过程。在微服务架构中，编排尤为重要，因为它涉及到多个独立服务之间的通信与合作。编排通常通过定义一系列步骤或工作流，确保每个服务在正确的时间点被调用，并处理可能出现的各种异常情况。编排是Java开发中不可或缺的一部分，特别是在构建复杂系统和微服务架构时。通过合理使用编排框架和工具，我们可以显著提升系统的效率、可靠性和可维护性。希望本文能够帮助大家更好地理解和应用Java中的编排技术。如果你对编排有任何疑问或想分享的经验，欢迎在评论区留言，让我们一起交流学习。
Java 线程池并行执行多个任务
m0_74288808的博客
05-03 1576
在上面的代码中，我们创建了一个 HelloWorldThreadPool 类，该类创建了一个线程池，并使用该线程池并行执行多个任务。每个任务都是一个简单的 Lambda 表达式，它打印出任务编号和当前线程的名称，然后睡眠 2 秒钟，最后再次打印任务编号和当前线程的名称。要运行此代码，您只需要使用 JDK 或 JRE 安装 Java 运行时环境，并将代码保存在名为 HelloWorldThreadPool.java 的文件中。然后，您应该可以看到多个任务并行执行，并在不同的线程中打印它们的编号和名称。
JAVA线程异步并发执行
偏偏行
04-22 854
注意:方式有多种,你也可以使用jdk1.8版本的自带的线程池,我这里还是使用Executor的子类ExecutorService
Java程序框架--多线程异步处理多任务
08-15
几乎所有的大型系统都有一个多任务多线程处理内核。本程序提供了一个多任务多线程异步处理框架。该框架使用简单，用户只需要继承抽象类Task,构建自己的任务类，再构造一个任务源，就可以轻松使用这个框架。 程序包里提供了一个例子Mytask 和MyTaskGenerator, 用户只需要运行类bootStraps即可。
JAVA8 CompletableFuture 异步编排 异步回调 案例实现 源码解析
NeverGiveUp
09-01 829
JUC CompletableFuture 异步编排 使用场景: ​ 当业务逻辑复杂时,特别是在微服务下,有些数据还需要远程调用.多个业务逻辑独立运行将耗费更多的时间. 例如: 查询商品基本信息 -> 0.5s 查询商品库存信息(远程调用) -> 1s 查询商品图片 -> 0.5s 查询商品规格属性 (依赖商品基本信息查询结果) -> 0.5s 提交所有商品信息
CompletableFuture实现异步编排全面分析和总结
m0_71777195的博客
03-14 488
结合了Future的优点，提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，提供了函数式编程的能力，可以通过回调的方式处理计算结果，并且提供了转换和组合的方法。被设计在Java中进行异步编程。异步编程意味着在主线程之外创建一个独立的线程，与主线程分隔开，并在上面运行一个非阻塞的任务，然后通知主线程进展，成功或者失败。是由Java8引入的，在Java8之前我们一般通过Future实现异步。Future。
CompletableFuture 异步编排、案例及应用小案例
Trouvailless的博客
08-22 536
今天的话，就来以一个应用场景来进行一步一步的推导，在实现案例的过程中，将相关的知识点逐步讲述明白。应用场景如下：我们在查询掘金文章页面数据为应用场景，如何使用异步编程进行优化。//1. 文章内容信息 1s//2. 作者相关信息 0.5s 依赖于1的查询结果//3. 文章评论信息 0.5s 依赖于1的查询结果//4. 文章分类信息 0.5s 依赖于1的查询结果//5. 文章专栏信息 0.5s 依赖于1的查询结果//6. 相关文章信息 0.5s 依赖于1的查询结果//...复制代码补充。
02-12 多任务异步协程实例
weixin_46400833的博客
02-12 161
一、注意事项： ''' 1、将多个对象存储到一个列表中，然后将该列表注册到事件循环中， 在注册过程中，该列表需要用wait方法进行处理 2、在任务对象对应的特殊函数内部的实现中，不可以出现不支持异步 模块的代码，否则会中断整个异步效果，并且在该函数的内部中每一 组阻塞操作都必须使用await关键字进行修饰 3、requests模块不支持异步，所以不能出现在async 修饰的函数中 二、代码框架 import time import asyncio urls=[ 'http://www.taob
Java多线程实现异步调用实例
09-18
Java多线程实现异步调用实例。运行Main可以看到结果。main是主线程，另有A,B,C三个线程用不同的时间跑完。
java 并行执行方法,Java 8中的异步方法及其后并行执行的方法
weixin_39538877的博客
02-16 209
After spending the day of learning about the java Concurrency API, I still dont quite get how could I create the following functionality with the help of CompletableFuture and ExecutorService classes:...
实际场景中的多线程并发编程案例
iNiBuBian的博客
12-06 7467
一、CountDownLatch CountDownLatch的用法 CountDownLatch典型用法1：某一线程在开始运行前等待n个线程执行完毕。将CountDownLatch的计数器初始化为n new CountDownLatch(n) ，每当一个任务线程执行完毕，就将计数器减1 countdownlatch.countDown()，当计数器的值变为0时，在CountDownLatch上 await() 的线程就会被唤醒。一个典型应用场景就是启动一个服务时，主线程需要等待多个组件加载完毕，之后再继
线程池详解与异步任务编排使用案例
doomwatcher的博客
10-11 731
【代码】线程池详解与异步任务编排使用案例。
JAVA：多线程异步并发提升程序性能的关键技术
木头
08-21 1807
多线程异步并发提升程序性能的关键技术
java 启动异步线程_java多线程之异步使用
weixin_32288959的博客
02-13 3460
在编程中,根据实际场景,我们有时会考虑使用异步执行来提高应用的响应速度;一个简单的例子:@Testpublic void futureTest() {// 注意使用 ExecutorService 而非 ExecutorExecutorService executorService = Executors.newFixedThreadPool(1);Future future = executor...
Executor线程池及其异步线程使用案例
pearkerChen
10-31 727
Executor框架的核心是线程池。线程池是指管理一组同构工作线程的资源池，具体可参考：https://www.cnblogs.com/timlearn/p/4023394.html https://blog.csdn.net/pozmckaoddb/article/details/51478017  https://www.cnblogs.com/zhaoyan001/p/7049627.h...
Java实现异步的4种方式
Zyw907155124的博客
05-29 9332
异步（Asynchronous）是指在进行多任务处理时，各个任务的执行不依赖于其他任务的完成，无需等待一个操作完成后再开始下一个操作。与之相对的是同步（Synchronous），同步操作需要按顺序执行，每个步骤必须等待前一个步骤完成才能开始。 1、Future与Callable 2. CompletableFuture 3. Spring框架的异步支持@Async 4. 使用消息队列RabbitMQ、Kafka
java通过线程池实现异步任务执行
03-29
Java通过线程池实现异步任务执行的步骤如下： 1. 创建线程池：使用Executor框架中的Executors类创建一个线程池，可以选择不同的线程池类型，例如FixedThreadPool、CachedThreadPool、ScheduledThreadPool等，根据需要选择合适的线程池类型。 2. 提交任务：将需要执行的任务封装成Runnable或Callable对象，通过Executor框架中的execute()或submit()方法提交任务到线程池。 3. 执行任务：线程池会从池中取出一个空闲的线程执行任务，如果所有线程都在忙碌状态，则任务会等待，直到有线程空闲为止。 4. 返回结果：如果任务是Callable类型，则可以通过Future对象获取任务执行结果。 5. 关闭线程池：在程序结束时，需要调用线程池的shutdown()方法来关闭线程池，释放资源，否则线程池会一直运行。 示例代码如下： ```java // 创建一个FixedThreadPool线程池，最多同时执行3个任务 ExecutorService threadPool = Executors.newFixedThreadPool(3); // 提交10个任务到线程池 for (int i = 0; i < 10; i++) { final int taskId = i; threadPool.execute(new Runnable() { @Override public void run() { System.out.println("Task " + taskId + " is running."); // 执行任务的代码 } }); } // 关闭线程池 threadPool.shutdown(); ```
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

厉害哥哥吖

您的支持是我创作下去的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值