java线程池异步使用

已于 2022-05-24 20:58:09 修改
阅读量4.4k 收藏 37
点赞数 7
文章标签： java 开发语言
于 2022-05-23 18:32:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/thebinso/article/details/124932333
版权

我们都知道代码块的执行顺序，一般是从上至下执行；

如果有三个方法，从上至下执行的话需要花1.5s；

如果使用线程池异步执行的话，只需要0.5s，这将大大减少方法整体执行时间；

下面介绍，线程池的创建及使用。

1.创建线程池

 有两种方法可以创建线程池，推荐使用第一种。

1.1创建原生的线程池对象（本人推荐使用这个）

package com.wanxin.gulimall.order.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 common
 * @date 2022/05/19
 */
@Configuration
public class MyThreadConfig {
    @Bean
    public ThreadPoolExecutor threadPoolExecutor(ThreadPoolConfigProperties pool) {
       return  new ThreadPoolExecutor(
                //核心线程数量
                  20,
                //最大线程数量
                  200,
                //最大存活时间
                  10,
                //单位秒
                TimeUnit.SECONDS,
                //队列，
                new LinkedBlockingDeque<>(100000),
                //线程工厂，构建线程
                Executors.defaultThreadFactory(),
                //任务具有策略
                new ThreadPoolExecutor.AbortPolicy());
    }

}

1.2 使用Executors的工具方法直接得到一个线程池对象

package d7_threadpool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

//使用Executors的工具方法直接得到一个线程池对象
public class ThreadPoolDemo3 {
    public static void main(String[] args) {
        //1.创建固定数量的线程池
        ExecutorService pool= Executors.newFixedThreadPool(3);

    }
}

2.操作线程池实现方法异步执行

2.1 runAsync ()方法 --- 无返回值

2.2 supplyAsync()方法 --- 有返回值

package com.wanxin.gulimall.search.thread;

import java.util.concurrent.*;

/**
* 线程测试
*
* @author 万天铭
* @date 2022/05/18
*/
public class thread {
    public static ExecutorService executor = Executors.newFixedThreadPool(10);
    
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        
        /*无返回值*/
        CompletableFuture<Void> runAsync = CompletableFuture.runAsync(() -> {
            System.out.println("当前线程"+Thread.currentThread().getId());
            int i=10/2;
            System.out.println("运行结果"+i);
        }, executor);
    }
        }

2.3 whenComplete() 方法 --- 方法完成后的感知

package com.wanxin.gulimall.search.thread;

import java.util.concurrent.*;

/**
* 线程测试
*
* @author 万天铭
* @date 2022/05/18
*/
public class thread {
    public static ExecutorService executor = Executors.newFixedThreadPool(10);
    
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        
       /*方法完成后的感知*/
        CompletableFuture<Integer> supplyAsync = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果" + i);
            return i;
        }, executor).whenComplete((res,exception)->{
            //虽然能得到异常信息，但是无法修改返回数据
            System.out.println("异步任务完成。。。结果是："+res+";异常是"+exception);
        }).exceptionally(throwable -> {
            //可以感知异常，同时返回默认值
            return 10;
        });
        
       
    }
        }

运行结果：

2.3 handle()方法 --- 方法完成后的处理

package com.wanxin.gulimall.search.thread;

import java.util.concurrent.*;

/**
* 线程测试
*
* @author 万天铭
* @date 2022/05/18
*/
public class thread {
    public static ExecutorService executor = Executors.newFixedThreadPool(10);
    
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        
            /*方法完成后的处理*/
        CompletableFuture<Integer> supplyAsync1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果" + i);
            return i;
        }, executor).handle((res,thr)->{
            if (res!=null){
                System.out.println("处理结果" +res*2);
                return res*2;
            }
            if (thr!=null){
                return 0;
            }
            return 0;
        });
        
       
    }
        }

运行结果： 

3.线程串行化

3.1 thenRunAsync --- 不能获取上一步的执行结果，无返回值

3.2 thenAcceptAsync --- 能接收上一步的结果，但是无返回值

3.3 thenApplyAsync --- 能接收上一步的结果，而且有返回值

     /*
        * 线程串行化
        * 1) thenRunAsync: 不能获取上一步的执行结果，无返回值
        * .thenRunAsync(() -> {
            System.out.println("任务2启动了");
        }, executor);
        *
        * 2) thenAcceptAsync: 能接收上一步的结果，但是无返回值
        * .thenAcceptAsync(res->{
            System.out.println("任务2启动了"+res);
        });
        *
        * 3)thenApplyAsync 能接收上一步的结果，而且有返回值
        * */
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果" + i);
            return i;
        }, executor).thenApplyAsync(res -> {
            System.out.println("任务2启动了" + res);
            return "hello" + res;
        }, executor);

        System.out.println("任务2返回值"+future.get());
    }

运行结果： 

 ​​​​​​​

3.4 runAfterBothAsync  等待前两个任务执行完之后再执行此方法（无返回值）

3.5 thenAcceptBothAsync  等待前两个任务执行完之后再执行此方法（有返回值）

3.6 runAfterEitherAsync  两个任务，只要一个执行完成，就执行任务3 ( 不感知结果，自己业务返回值)

3.7 anyOf 必须所有任务执行完成，才算成功

3.8 allOf  只要一个执行完成，就算成功

 CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务线程1");
            return "任务线程1";
        }, executor);

        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务线程2");
            return "任务线程2";
        }, executor);

        CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务线程3");
            return "任务线程3";
        }, executor);


        /* 等待前两个任务执行完之后再执行此方法（无返回值）*/
        future1.runAfterBothAsync(future2,()->{
            System.out.println("任务线程3开始");
        }, executor);


        /* 等待前两个任务执行完之后再执行此方法（有返回值）*/
//        future1.thenAcceptBothAsync(future2,(f1,f2)->{
//            System.out.println("任务线程3开始,之前的结果："+f1+"---->>"+f2);
//        },executor);


         /*
         * 两个任务，只要一个执行完成，就执行任务3
         * runAfterEitherAsync 不感知结果，自己业务返回值
         * */
//        future1.runAfterEitherAsync(future2,()->{
//           System.out.println("任务线程3开始");
//       },executor);


//        /*必须所有任务执行完成，才算成功*/
//        CompletableFuture<Object> allOf = CompletableFuture.allOf(future1, future2, future3);
//        anyOf.get();
//
//
//        /*只要一个执行完成，就算成功*/
//        CompletableFuture<Void> anyOf = CompletableFuture.anyOf(future1, future2, future3);
//        future.get();

4.项目线程池异步执行案例

4.1 application.properties配置文件中定义变量

gulimall.thread.coreSize=20
gulimall.thread.maxSize=200
gulimall.thread.keepAliveTime=10

4.2 定义类接收变量

package com.atguigu.gulimall.product.config;

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

/**
 * 线程池配置属性
 *
 * @author common
 * @date 2022/05/19
 */
@ConfigurationProperties(prefix = "gulimall.thread")
@Component
@Data
public class ThreadPoolConfigProperties {

    private Integer coreSize;

    private Integer maxSize;

    private Integer keepAliveTime;
}

4.3 线程池属性配置

package com.atguigu.gulimall.product.config;


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

import java.util.concurrent.*;

/**
 * 我线配置
 *
 * @author common
 * @date 2022/05/19
 */
@Configuration
public class MyThreadConfig {
    @Bean
    public ThreadPoolExecutor threadPoolExecutor(ThreadPoolConfigProperties pool) {
       return  new ThreadPoolExecutor(
                //核心线程数量
               pool.getCoreSize(),
                //最大线程数量
                pool.getMaxSize(),
                //最大存活时间
               pool.getKeepAliveTime(),
                //单位秒
                TimeUnit.SECONDS,
                //队列，
                new LinkedBlockingDeque<>(100000),
                //线程工厂，构建线程
                Executors.defaultThreadFactory(),
                //任务具有策略
                new ThreadPoolExecutor.AbortPolicy());
    }

}

4.4 使用线程池

@Autowired
ThreadPoolExecutor threadPoolExecutor;

    @Override
    public SkuItemVo item(Long skuId) throws ExecutionException, InterruptedException {
        //1、sku基本信息的获取  pms_sku_info
        SkuItemVo skuItemVo=new SkuItemVo();

        CompletableFuture<SkuInfoEntity> infoFuture = CompletableFuture.supplyAsync(() -> {
            SkuInfoEntity info = getById(skuId);
            skuItemVo.setInfo(info);
            return info;
        }, threadPoolExecutor);


        //==============================下面三个异步==================================//
        CompletableFuture<Void> attrFuture = infoFuture.thenAcceptAsync(res -> {
            //3、获取spu的销售属性组合
            List<SkuItemSaleAttrVo> saleAttrVos = skuSaleAttrValueService.getSaleAttrBySpuId(res.getSpuId());
            skuItemVo.setSaleAttr(saleAttrVos);
        }, threadPoolExecutor);

        CompletableFuture<Void> descFuture = infoFuture.thenAcceptAsync(res -> {
            //4、获取spu的介绍
            SpuInfoDescEntity spuInfoDescEntity = spuInfoDescService.getById(res.getSpuId());
            skuItemVo.setDesc(spuInfoDescEntity);
        }, threadPoolExecutor);

        CompletableFuture<Void> baseAttrFuture = infoFuture.thenAcceptAsync(res -> {
            //5、获取spu的规格参数信息
            List<SpuItemAttrGroupVo> attrGroupVos = attrGroupService.getAttrGroupWithAttrsBySpuId(res.getSpuId(), res.getCatalogId());
            skuItemVo.setGroupAttrs(attrGroupVos);
        }, threadPoolExecutor);
        //================================================================//


        CompletableFuture<Void> imagesFuture= CompletableFuture.runAsync(() -> {
            //2、sku的图片信息   pms_sku_images
            List<SkuImagesEntity> imagesEntities = skuImagesService.getImagesBySkuId(skuId);
            skuItemVo.setImages(imagesEntities);
        }, threadPoolExecutor);


        //等待所有任务都完成
        CompletableFuture.allOf(attrFuture,descFuture,baseAttrFuture,imagesFuture).get();

       return skuItemVo;
    }

廖小聪
关注
  • 7
    点赞
  • 踩
  • 37
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java并发编程 线程池 异步编排
08-04
java并发编程相关总结
java线程池&子线程&事务&异步返回监听实战
10-20
在java开发中，往往会遇到一个请求需要处理很多次数据库，想要分成多个线程异步处理，在此给出个一个试例完成上述需求，子事务的成败会控制主线程的事务，并利用了CompletableFuture实现异步监听，@Async注解实现了...
Java开启异步线程的几种方法
qq_42923605的博客
03-22 2444
在java中异步线程很重要，比如在业务流处理时，需要通知硬件设备，发短信通知用户，或者需要上传一些图片资源到其他服务器这种耗时的操作，在主线程里处理会阻塞整理流程，而且我们也不需要等待处理结果之后再进行下一步操作，这时候就可以使用异步线程进行处理，这样主线程不会因为这些耗时的操作而阻塞，保证主线程的流程可以正常进行。在springboot框架中，可以使用注解简单实现线程的操作，还有AsyncManager的方式，如果需要复杂的线程操作，可以使用线程池实现。最近在项目中使用了很多线程的操作，在这做个记录。
java异步与线程池
最新发布
onePlus5T的博客
05-17 826
Executors.创建⼀个固定⼤⼩的线程池，可控制并发的线程数，超出的线程会在队列中等待；Executors.创建⼀个可缓存的线程池，若线程数超过处理所需，缓存⼀段时间后会回收，若线程数不够，则新建线程；Executors.创建单个线程数的线程池，它可以保证先进先出的执⾏顺序；Executors.创建⼀个可以执⾏延迟任务的线程池；是以period为间隔来执行任务的，如果任务执行时间小于period，则上次任务执行完成后会间隔period后再去执行下一次任务；
java多线程
StringBuffer Obj 的博客
09-22 244
java 线程创建、线程状态、线程同步、线程协作问题
java线程池和异步任务
Double_dddddddd的博客
12-01 221
1、创建自定义线程池1、创建自定义线程池2、创建异步任务。
Java线程池和Spring异步处理高级篇
supeerzdj的博客
06-30 426
好了Spring处理异步的过程都说了，我们也看到Spring的异步处理器不是太好，需要我们自己配置默认的线程池，还有如果程序中有返回结果一定要记得把返回结果用Futrue封装一下，要不然写出来的程序可能出现空指针的情况【PS你已经是一个成熟的开发了，要记得自己避免空指针。好了看了获取默认线程池的方法了，对我们后面配置程序中自己的线程池就有了很大的帮助了，慢慢知道我一开始为啥要先聊线程池了吗，放心不会骗你的【PS呸呸呸 这句话说的是不是有点渣）这个时候可能会有小伙伴说这使用也太简单了，讲上面的线程池没有啊。
java实现异步任务功能的方法
weixin_49999835的博客
07-20 2428
方法名说明传入实现了 Runnable 接口的类，构造一个 Thread 对象传入实现了 Runnable 接口的类，构造一个名称为 name 的 Thread 对象方法名说明V call()这是 Callable 接口中要实现的方法，相当于 Runnable 接口中的 run 方法使用 Callable 接口实现类实例创建一个 FutureTask，它运行时会调配用 Callable 接口中的 call 方法V get()
spring boot使用自定义配置的线程池执行Async异步任务
08-28
Spring Boot 使用自定义配置的线程池执行 Async 异步任务 在 Spring Boot 中执行异步任务时，默认情况下使用的是默认的线程池，但是，在实际项目中，我们可能需要根据项目的需求来定制自己的线程池。下面将介绍如何...
Java四种线程池的使用详解
08-29
Java四种线程池的使用详解 Java四种线程池的使用详解是Java多线程编程中的一种重要概念。Java通过Executors提供四种线程池，分别为newCachedThreadPool、newFixedThreadPool、newScheduledThreadPool和...
java 四种线程池实例
06-06
执行一个异步任务你还只是如下new Thread吗？是不是太low 了一点？ 我这里有四种线程池的案例轻松让你理解和使用线程池。
异步调用—线程池技术
bai259257的博客
05-26 798
同步调用：实时处理，就是在发出一个调用时，在没有得到结果之前， 该调用就不返回 。 优点：时效性较强，可以立即得到结果 缺点：耦合度高、性能和吞吐能力下降、有额外的资源消耗、有级联失败问题 异步调用：分时处理，调用在发出之后，这个调用就直接返回了，没有返回结果。 异步调用分为两种：1. 跨服务调用，MQ；2. 在一个服务中调用，线程池技术 同步调用，虽然可以实时得到结果，但是响应时常太慢了，业务逻辑复杂，用户体验不好。所以在一个服务中使用的线程池技术。这种方式可以立刻给客户做出回应，十分优雅。
JAVA项目中的异步任务
大风的博客
04-09 7128
如果需要自定义线程池需要在。
如何实现Java代码中实现异步操作，利用线程池newScheduledThreadPool
chuwen2022的博客
06-13 1502
在实际开发中，会遇到一种情况，就是需要把数据同步到别渠道，然而同步这个操作又很费时，为了不影响当前功能的页面响应，这个时候可以考虑类似ajax中异步操作的想法，这个时候可以利用java的线程池来实现，代码如下： public class SyncAppInfoToOtherChannelUt...
Java - JUC(java.util.concurrent)包详解，其下的锁、安全集合类、线程池相关、线程创建相关和线程辅助类、阻塞队列
m0_65228708的博客
12-09 1484
JUC是什么？ Java中线程有六个状态 JUC的结构 synchronized和JUC的Lock 　 reentrantLock 　 Condition 　 JUC下的读写锁ReentrantReadWriteLock 不安全的集合类和JUC的collections 　 list 不安全-CpoyOnWriteArrayList 　 set 不安全-CopyOnWriteArraySet 　 HashMap不安全-ConcurrentHashMap JUC的Callab
异步编排CompletableFuture
xiang_yu_pai的博客
07-25 240
异步编排使用CompletableFuture执行方法runAsync()返回空值 supplyAsync()返回结果handle() 感知异常并且能返回结果thenRunAsync()方法 不接受上一步结果执行，不返回结果thenAcceptAsync()方法 接受上一步结果，但不返回结果thenApplyAsync()方法 接受上一步结果，返回结果runAfterBothAsync()不接受结果，不返回结果thenAcceptBothAsync()接受结果，不返回结果thenCombine
Java中的异步与线程池
weixin_47409774的博客
03-20 7108
初始化线程的4种方式 1、继承Thread Thread01 thread01 = new Thread01(); thread01.start(); public static class Thread01 extends Thread{ @Override public void run() { System.out.println("当前线程："+Thread.currentThread().getId());
java并发编程--Executor框架
weixin_30335353的博客
04-26 577
摘要： Eexecutor作为灵活且强大的异步执行框架，其支持多种不同类型的任务执行策略，提供了一种标准的方法将任务的提交过程和执行过程解耦开发，基于生产者-消费者模式，其提交任务的线程相当于生产者，执行任务的线程相当于消费者，并用Runnable来表示任务，Executor的实现还提供了对生命周期的支持，以及统计信息收集，应用程序管理机制和性能监视等机制。 1.Exexc...
java 使用多线程池异步处理不同业务
春风化雨
10-10 677
【代码】java多个线程池分别异步处理不同业务。
c++线程池异步调用
01-01
以下是一个使用C++线程池进行异步调用的示例： ```cpp #include <iostream> #include <thread> #include <functional> #include <vector> #include <queue> #include <mutex> #include <condition_variable> class ThreadPool { public: ThreadPool(size_t numThreads) : stop(false) { for (size_t i = 0; i < numThreads; ++i) { threads.emplace_back([this] { while (true) { std::function<void()> task; { std::unique_lock<std::mutex> lock(queueMutex); condition.wait(lock, [this] { return stop || !tasks.empty(); }); if (stop && tasks.empty()) { return; } task = std::move(tasks.front()); tasks.pop(); } task(); } }); } } template<class F, class... Args> void enqueue(F&& f, Args&&... args) { { std::unique_lock<std::mutex> lock(queueMutex); tasks.emplace([=] { std::invoke(f, args...); }); } condition.notify_one(); } ~ThreadPool() { { std::unique_lock<std::mutex> lock(queueMutex); stop = true; } condition.notify_all(); for (std::thread& thread : threads) { thread.join(); } } private: std::vector<std::thread> threads; std::queue<std::function<void()>> tasks; std::mutex queueMutex; std::condition_variable condition; bool stop; }; // 示例任务函数 void printHello(int id) { std::cout << "Hello from thread " << id << std::endl; } int main() { ThreadPool pool(4); // 创建一个拥有4个线程的线程池 // 向线程池中添加任务 for (int i = 0; i < 10; ++i) { pool.enqueue(printHello, i); } // 等待所有任务完成 // 这里不需要使用pthread_join函数，线程池会自动处理任务的执行和完成 // 当线程池析构时，会等待所有任务完成后再退出 // 所以在这里不需要显式地调用join函数 // 但是需要注意的是，如果在线程池析构前没有等待所有任务完成，可能会导致任务被中断 // 所以在实际使用中，需要根据具体情况来决定何时销毁线程池 return 0; } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值