springBoot 多线程+线程池处理+等待获取执行结果 (Future)(CompletableFuture)

springBoot 多线程+线程池处理+等待获取执行结果(Future)(CompletableFuture)

Java 线程池

Java通过Executors提供四种线程池,分别为:

newCachedThreadPool创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。
newFixedThreadPool 创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池,支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

优点
重用存在的线程,减少对象创建、消亡的开销,性能佳。
可有效控制最大并发线程数,提高系统资源的使用率,同时避免过多资源竞争,避免堵塞。
提供定时执行、定期执行、单线程、并发数控制等功能。

在springboot项目中一般使用方法二。

一、方法一(CountDownLatch)

public class StatsDemo {
    final static SimpleDateFormat sdf = new SimpleDateFormat(
            "yyyy-MM-dd HH:mm:ss");

    final static String startTime = sdf.format(new Date());

    /**
     * IO密集型任务  = 一般为2*CPU核心数(常出现于线程中:数据库数据交互、文件上传下载、网络数据传输等等)
     * CPU密集型任务 = 一般为CPU核心数+1(常出现于线程中:复杂算法)
     * 混合型任务  = 视机器配置和复杂度自测而定
     */
    private static int corePoolSize = Runtime.getRuntime().availableProcessors();
    /**
     * public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,
     *                           TimeUnit unit,BlockingQueue<Runnable> workQueue)
     * corePoolSize用于指定核心线程数量
     * maximumPoolSize指定最大线程数
     * keepAliveTime和TimeUnit指定线程空闲后的最大存活时间
     * workQueue则是线程池的缓冲队列,还未执行的线程会在队列中等待
     * 监控队列长度,确保队列有界
     * 不当的线程池大小会使得处理速度变慢,稳定性下降,并且导致内存泄露。如果配置的线程过少,则队列会持续变大,消耗过多内存。
     * 而过多的线程又会 由于频繁的上下文切换导致整个系统的速度变缓——殊途而同归。队列的长度至关重要,它必须得是有界的,这样如果线程池不堪重负了它可以暂时拒绝掉新的请求。
     * ExecutorService 默认的实现是一个无界的 LinkedBlockingQueue。
     */
    private static ThreadPoolExecutor executor  = new ThreadPoolExecutor(corePoolSize, corePoolSize+1, 10l, TimeUnit.SECONDS,
            new LinkedBlockingQueue<Runnable>(1000));

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(5);
        //使用execute方法
          executor.execute(new Stats("任务A", 1000, latch));
          executor.execute(new Stats("任务B", 1000, latch));
          executor.execute(new Stats("任务C", 1000, latch));
          executor.execute(new Stats("任务D", 1000, latch));
          executor.execute(new Stats("任务E", 1000, latch));
        latch.await();// 等待所有人任务结束
        System.out.println("所有的统计任务执行完成:" + sdf.format(new Date()));
    }

    static class Stats implements Runnable  {
        String statsName;
        int runTime;
        CountDownLatch latch;

        public Stats(String statsName, int runTime, CountDownLatch latch) {
            this.statsName = statsName;
            this.runTime = runTime;
            this.latch = latch;
        }

        public void run() {
            try {
                System.out.println(statsName+ " do stats begin at "+ startTime);
                //模拟任务执行时间
                Thread.sleep(runTime);
                System.out.println(statsName + " do stats complete at "+ sdf.format(new Date()));
                latch.countDown();//单次任务结束,计数器减一
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

二、方法二(Future)

重点是和springBoot整合,采用注解bean方式生成ThreadPoolTaskExecutor
在springBoot项目中开启异步线程需要满足一下几点

  • 在启动类加入异步线程注解@EnableAsync
  • 创建线程池并创建Bean实例
1. 自定义线程池
@Configuration
//@EnableAsync
public class ThreadPoolConfig
{

    /**
     *   默认情况下,在创建了线程池后,线程池中的线程数为0,当有任务来之后,就会创建一个线程去执行任务,
     *  当线程池中的线程数目达到corePoolSize后,就会把到达的任务放到缓存队列当中;
     *  当队列满了,就继续创建线程,当线程数量大于等于maxPoolSize后,开始使用拒绝策略拒绝
     */

    /**
     * 获得Java虚拟机可用的处理器个数 + 1
     */
    private static final int THREADS = Runtime.getRuntime().availableProcessors() + 1;

    @Value("${async.executor.thread.core_pool_size:0}")
    public static int corePoolSizeConfig;
    // 核心线程池大小
    public static int corePoolSize = corePoolSizeConfig ==0 ? THREADS : corePoolSizeConfig;

    // 最大可创建的线程数
    //@Value("${async.executor.thread.max_pool_size}")
    private int maxPoolSize = 2 * THREADS;;

    // 队列最大长度
    //@Value("${async.executor.thread.queue_capacity}")
    private int queueCapacity = 1024;

    // 线程池维护线程所允许的空闲时间
    //@Value("${async.executor.thread.keep_alive_seconds}")
    private int keepAliveSeconds = 300;


    //线程池名前缀 
    //@Value("${async.executor.thread.threadNamePrefix}")
    private static final String threadNamePrefix = "Async-Service-";

    @Bean(name = "threadPoolTaskExecutor")
    public ThreadPoolTaskExecutor threadPoolTaskExecutor()
    {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setMaxPoolSize(maxPoolSize);
        executor.setCorePoolSize(corePoolSize);
        executor.setQueueCapacity(queueCapacity);
        executor.setKeepAliveSeconds(keepAliveSeconds);
        executor.setThreadNamePrefix(threadNamePrefix);
        // 线程池对拒绝任务(无线程可用)的处理策略
       // CallerRunsPolicy:由调用线程(提交任务的线程)处理该任务
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
      // 初始化
        executor.initialize();
        return executor;
    }

}
2. 异步执行方法

启动类添加@EnableAsync注解

@SpringBootApplication
@EnableAsync
@EnableScheduling
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

service层方法

@Service
public class AsyncInvokeService {

    @Async("threadPoolTaskExecutor")
    public Future<Boolean> exec1(String name) {
        System.out.println("子线程 name -->" + Thread.currentThread().getName());
        System.out.println(name);
        Thread.sleep(10000);
        return new AsyncResult<>(true);
    }

    @Async("threadPoolTaskExecutor")
    public Future<Boolean> exec2(String phone) {
        System.out.println("子线程 name -->" + Thread.currentThread().getName());
        System.out.println(phone);
        Thread.sleep(10000);
        return new AsyncResult<>(true);
    }
3. 多线程执行返回结果
    @GetMapping("/gettest")
    public String b() throws InterruptedException, ExecutionException {
        Future<Boolean> future1 = asyncInvokeService.exec1("张三");
        Future<Boolean> future2 = asyncInvokeService.exec2("15618881888");

        List<Future<Boolean>> futureList = new ArrayList<>();      
        futureList.add(future1);
        futureList.add(future2);

        //查询任务执行的结果
        for (Future<?> future : futureList) {
            while (true) {//CPU高速轮询:每个future都并发轮循,判断完成状态然后获取结果,这一行,是本实现方案的精髓所在。即有10个future在高速轮询,完成一个future的获取结果,就关闭一个轮询
                if (future.isDone() && !future.isCancelled()) { //获取future成功完成状态,如果想要限制每个任务的超时时间,取消本行的状态判断+future.get(1000*1, TimeUnit.MILLISECONDS)+catch超时异常使用即可。
                    Boolean result = future.get();//获取结果
                    System.out.println("任务i=" + i + "获取完成!" + new Date());
                    list.add(result);
                    break;//当前future获取结果完毕,跳出while
                } else {
                    Thread.sleep(1);//每次轮询休息1毫秒(CPU纳秒级),避免CPU高速轮循耗空CPU---》新手别忘记这个
                }
            }
        }
        return "执行成功!!";
    }

三、方法三(CompletableFuture)

示例:

1、线程池

@Configuration
//@EnableAsync
public class ThreadPoolConfig {

    /**
     *   默认情况下,在创建了线程池后,线程池中的线程数为0,当有任务来之后,就会创建一个线程去执行任务,
     *  当线程池中的线程数目达到corePoolSize后,就会把到达的任务放到缓存队列当中;
     *  当队列满了,就继续创建线程,当线程数量大于等于maxPoolSize后,开始使用拒绝策略拒绝
     */

    /**
     * 获得Java虚拟机可用的处理器个数 + 1
     */
    private static final int THREADS = Runtime.getRuntime().availableProcessors() + 1;

    //    @Value("${async.executor.thread.core_pool_size:0}") //可在配置文件配置核心线程数
    public static int corePoolSizeConfig = 0;
    // 核心线程池大小
    public static int coreIoPoolSize = (corePoolSizeConfig == 0 ? THREADS : corePoolSizeConfig) * 4;

    // 最大可创建的线程数
    //@Value("${async.executor.thread.max_pool_size}")
    private int maxIoPoolSize = 4 * 2 * THREADS;

    // 核心线程池大小
    public static int coreCpuPoolSize = corePoolSizeConfig == 0 ? THREADS : corePoolSizeConfig;

    // 最大可创建的线程数
    //@Value("${async.executor.thread.max_pool_size}")
    private int maxCpuPoolSize = 2 * THREADS;


    // 队列最大长度
    //@Value("${async.executor.thread.queue_capacity}")
    private int queueCapacity = 1024;

    // 线程池维护线程所允许的空闲时间
    //@Value("${async.executor.thread.keep_alive_seconds}")
    private int keepAliveSeconds = 60;


    //线程池名前缀
    //@Value("${async.executor.thread.threadNamePrefix}")
    private static final String threadNamePrefix = "Async-Service-";

    /**
     * IO 密集类型线程池 (corePoolSize 核心线程 和 maxPoolSize最大线程数比cpu核数翻4倍)
     *
     * @return
     */
    @Bean(name = "threadIoPoolTaskExecutor")
    public ThreadPoolTaskExecutor threadIoPoolTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setMaxPoolSize(maxIoPoolSize);
        executor.setCorePoolSize(coreIoPoolSize);
        executor.setQueueCapacity(queueCapacity);
        executor.setKeepAliveSeconds(keepAliveSeconds);
        executor.setThreadNamePrefix(threadNamePrefix);
        // 线程池对拒绝任务(无线程可用)的处理策略
        // CallerRunsPolicy:由调用线程(提交任务的线程)处理该任务
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 初始化
        executor.initialize();
        return executor;
    }

    /**
     * cpu 密集类型线程池
     *
     * @return
     */
    @Bean(name = "threadCpuPoolTaskExecutor")
    public ThreadPoolTaskExecutor threadCpuPoolTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setMaxPoolSize(maxCpuPoolSize);
        executor.setCorePoolSize(coreCpuPoolSize);
        executor.setQueueCapacity(queueCapacity);
        executor.setKeepAliveSeconds(keepAliveSeconds);
        executor.setThreadNamePrefix(threadNamePrefix);
        // 线程池对拒绝任务(无线程可用)的处理策略
        // CallerRunsPolicy:由调用线程(提交任务的线程)处理该任务
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 初始化
        executor.initialize();
        return executor;
    }


}

2、调用

@Service
@Slf4j
public class TestServiceImpl  implements TestService {
    @Autowired
    private Executor threadIoPoolTaskExecutor;
    
    public void testCompletableFuture(){

        //并行调用 提供执行效率
        CompletableFuture<String> a = CompletableFuture.supplyAsync(() -> testAsync("a"), threadIoPoolTaskExecutor);
        CompletableFuture<String> b = CompletableFuture.supplyAsync(() -> testAsync("b"), threadIoPoolTaskExecutor);
        CompletableFuture<String> c = CompletableFuture.supplyAsync(() -> testAsync("c"), threadIoPoolTaskExecutor);

        try {
            String resultA = a.get();
            String resultB = b.get();
            String resultC = c.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

    public String testAsync(String s){
        //耗时操作
        
        return s;
    }
}

参考:
SpringBoot线程池ThreadPoolExecutor
SpringBoot线程池ThreadPoolTaskExecutor

03-08
### 关于MinerU的技术信息 MinerU是一个一站式的开源高质量数据提取工具,支持PDF、网页以及多格式电子书等多种形式的数据源中的内容抽取工作[^2]。对于希望从不同类型的文件或者在线资源里高效获取有用资料的研究人员或是开发者来说非常实用。 #### 获取途径 - **官方网站**: 可访问[MinerU官网](https://mineru.net/)了解更多信息并下载软件。 - **GitHub仓库**: [MinerU GitHub页面](https://github.com/opendatalab/MinerU)提供了完整的项目代码和开发文档,方便有兴趣深入了解或参与到这个项目的个人查阅。 - **线上演示环境**: 如果想要先体验一下MinerU的功能而不必立即安装本地版本,则可以尝试进入[线上Demo入口](https://mineru.net/OpenSourceTools/Extractor)[^1]。 #### Docker启动指南 为了便于部署和服务运行,在Docker容器中启动MinerU服务的方法如下所示: ```bash docker run -itd --name=mineru_server --gpus=all -p 8888:8000 quincyqiang/mineru:0.2-models ``` 这条命令会创建一个新的名为`mineru_server`的Docker实例,并将其内部端口映射到主机上的指定端口(这里默认为8888),同时分配所有的GPU给此容器使用以便加速某些计算密集型任务。需要注意的是,这里的端口号可以根据实际情况灵活调整[^5]。 #### 功能特性概述 作为一款专注于提升用户体验的产品,MinerU不仅限于基本的文字识别与结构化转换能力;更重要的是其具备高度灵活性——由于采用了开放源码的形式发布,任何人均可根据特定应用场景的需求对其进行个性化修改和发展,从而更好地服务于不同的业务流程。此外,这种模式也鼓励了更多人的加入和技术交流活动的发生,共同推动着整个生态系统的进步与发展。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值