异步ComplatableFuture

最新推荐文章于 2024-05-29 22:55:19 发布

廉小雨

最新推荐文章于 2024-05-29 22:55:19 发布

阅读量706

点赞数 1

文章标签：异步

本文链接：https://blog.csdn.net/weixin_40964170/article/details/118484574

版权

一、创建线程的4种方式

第1种、继承Thread类

public class ThreadTest {
    public static void main(String[] args) {
        Thread01 thread01 = new Thread01();
        new Thread(thread01).start();
    }

    public static class Thread01 extends Thread{
        @Override
        public void run() {
            System.out.println("current thread is: "+Thread.currentThread().getId());
            int i = 10/2;
            System.out.println("result is : "+i);
        }
    }
}

第2种、实现Runnable接口

public static class Thread02 implements Runnable{
        @Override
        public void run() {
            System.out.println("current thread is: "+ Thread.currentThread().getId());
            int i = 10/2;
            System.out.println("run result is: "+i);
        }
    }

第3种、实现Callable接口

public static class Thread03 implements Callable<Integer>{
        @Override
        public Integer call() throws Exception {
            System.out.println("Thread03 current thread is: "+ Thread.currentThread().getId());
            int i = 10/2;
            System.out.println("run result is: "+i);
            return i;
        }
    }

runnable和callable区别
Runnable没有返回值，Callable有返回值

第4种、线程池创建线程

public class ThreadTest {

    //创建原生线程池
    //ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor();
    //Executors线程池工具类创建线程池
    public static ExecutorService service = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws Exception {
        //当前系统池只有一两个，每个异步任务，提交给线程池让他自己去执行
        service.execute(new Thread02());
    }

    public static class Thread02 implements Runnable{
        @Override
        public void run() {
            System.out.println("current thread is: "+ Thread.currentThread().getId());
            int i = 10/2;
            System.out.println("run result is: "+i);
        }
    }

二、线程池的四种方式

Java通过Executors提供四种线程池，分别为：

第1种、使用newCachedThreadPool

newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

这种类型的线程池特点是：

工作线程的创建数量几乎没有限制(其实也有限制的,数目为Interger. MAX_VALUE), 这样可灵活的往线程池中添加线程。

如果长时间没有往线程池中提交任务，即如果工作线程空闲了指定的时间(默认为1分钟)，则该工作线程将自动终止。终止后，如果你又提交了新的任务，则线程池重新创建一个工作线程。

在使用CachedThreadPool时，一定要注意控制任务的数量，否则，由于大量线程同时运行，很有会造成系统瘫痪。

示例代码如下：

	public static void main(String[] args) {  
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();  
        for (int i = 0; i < 10; i++) {  
            final int index = i;  
            try {  
                Thread.sleep(10);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
            cachedThreadPool.execute(new Runnable() {  
                public void run() {  
                    System.out.println(index);  
                }  
            });  
        }  
    }

第2种、使用newFixedThreadPool

创建一个指定工作线程数量的线程池。每当提交一个任务就创建一个工作线程，如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列中。

FixedThreadPool是一个典型且优秀的线程池，它具有线程池提高程序效率和节省创建线程时所耗的开销的优点。但是，在线程池空闲时，即线程池中没有可运行任务时，它不会释放工作线程，还会占用一定的系统资源。

示例代码如下：

	public static void main(String[] args) {  
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);  
        for (int i = 0; i < 10; i++) {  
            final int index = i;  
            fixedThreadPool.execute(new Runnable() {  
                public void run() {  
                    try {  
                        System.out.println(index);  
                        Thread.sleep(10);  
                    } catch (InterruptedException e) {  
                        e.printStackTrace();  
                    }  
                }  
            });  
        }  
    }

因为线程池大小为3，每个任务输出index后sleep 2秒，所以每两秒打印3个数字。

定长线程池的大小最好根据系统资源进行设置如Runtime.getRuntime().availableProcessors()。

第2种、使用newSingleThreadExecutor

创建一个单线程化的Executor，即只创建唯一的工作者线程来执行任务，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO,优先级)执行。如果这个线程异常结束，会有另一个取代它，保证顺序执行。单工作线程最大的特点是可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。按顺序来执行线程任务但是不同于单线程，这个线程池只是只能存在一个线程，这个线程死后另外一个线程会补上

示例代码如下：

	public static void main(String[] args) {  
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();  
        for (int i = 0; i < 10; i++) {  
            final int index = i;  
            singleThreadExecutor.execute(new Runnable() {  
                public void run() {  
/*                  System.out.println(index);*/  
                    try {  
                        System.out.println(index);  
                        Thread.sleep(2000);  
                    } catch (InterruptedException e) {  
                        e.printStackTrace();  
                    }  
                }  
            });  
        }  
    }

第4种、使用newScheduledThreadPool

创建一个定长的线程池，而且支持定时的以及周期性的任务执行，支持定时及周期性任务执行。

延迟3秒执行，延迟执行示例代码如下：

	public static void main(String[] args) {  
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);  
        for (int i = 0; i < 10; i++) {  
            scheduledThreadPool.schedule(new Runnable() {  
                public void run() {  
                    System.out.println("delay 3 seconds");  
                }  
            }, 3, TimeUnit.SECONDS);  
        }  
  
    }

三、原生线程池的参数

public ThreadPoolExecutor(
                          //核心线程池，不管公司是否倒闭，核心人数不变
						  int corePoolSize,
						  //最大线程数，公司最多就招100人，不管任务多少
                          int maximumPoolSize,
                          //存活时间，如果当前的线程数量大于核心线程数量，只要线程空闲时间大于存活时间，就会释放线程（最大线程数量-核心线程数量）
                          //核心线程就是老板亲信，其他人如果空闲时间大于老板心里的空闲时间，就会被辞退（公司总人数-老板亲信人数=会被裁的人数）
                          long keepAliveTime,
                          //时间单位
                          TimeUnit unit,
                          //阻塞队列，如果任务很多，就会将多余任务放到队列里，如果有空闲的线程，就会去队列取出任务执行
                          BlockingQueue<Runnable> workQueue,
                          //线程的创建工厂
                          ThreadFactory threadFactory,
                          //如果队列满了，就执行拒绝策略
                          RejectedExecutionHandler handler)

在这里插入图片描述

运行流程：

1、线程池创建，准备好core数量的核心线程，准备接受任务
2、新的任务进来，用core准备好的空闲线程执行

core满了，就将再进来的任务放入阻塞队列中，空闲的core就会自己去阻塞队列获取任务执行
阻塞队列满了，就会直接开新线程执行，最大只能开到max指定的数量
max都执行好了，max-core数量空闲的线程会在keepAliveTime指定的时间后自动销毁，最终保持到core大小
如果线程数开到了max的数量，还有新任务进来，就会使用reject指定的拒绝策略进行处理

3、所有的线程创建都是由指定的factor创建

通俗理解

1、新公司成立，准备好核心员工人数
2、任务来了，不忙的核心员工负责处理
①如果核心员工们的工作都满了，就将再来的任务记到任务表里，谁不忙了再去处理这些队列中的任务
②如果任务表都排满了，就直接再招聘新员工，人数不能大于老板指定数量
③如果任务都完成了，除了核心员工，其他后进来的员工如果空闲时间大于指定时间就被辞退
④如果招聘了最大数量员工，还是有完不成的任务，就拒绝再去执行新的任务
3、所有的员工招聘都由老板负责

问题：
一个线程池 core 7，max 20，queue 50,100个并发进来怎么分配？
答：7个任务会立即执行，50个任务会进入队列，最多再开13个线程，剩下的30个线程就使用拒绝策略，如果不想抛弃还要执行，就使用callerRunsPolicy

四、CompletableFuture

在这里插入图片描述

1、创建异步对象

CompletableFuture 提供了四个静态方法来创建一个异步操作

#runAsync 无返回值
public static CompletableFuture<Void> runAsync(Runable runable)
public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor)

#supplyAsync 有返回值
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor)

2、Completable启动异步任务

runAsync()，无返回值

package com.lian.gulimall.search.thread;

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

public class ThreadTestAsyn {

    //创建线程池
    public static ExecutorService executor = Executors.newFixedThreadPool(10);
    
    public static void main(String[] args) throws Exception {
        //1、Async创建异步对象，没返回值
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            //异步任务内容
            System.out.println("current thread: " + Thread.currentThread().getId());
            int i = 10 / 2;
           System.out.println("run result: " + i);
        }, executor);
        System.out.println("main...end..");
    }
}

supplyAsync()，有返回值

package com.lian.gulimall.search.thread;

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

public class ThreadTestAsyn {

    //创建线程池
    public static ExecutorService executor = Executors.newFixedThreadPool(10);
    
    public static void main(String[] args) throws Exception {
    
        //2、Supply，有返回值
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("current thread: " + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("run result: " + i);
            return i;
        }, executor);
        Integer integer = future.get();
        System.out.println(integer);
        System.out.println("main...end..");
    }
}

3、Completable异步完成回调与异常感知

whenComplete：返回结果和异常
exceptionally：如果出现异常，返回默认值

package com.lian.gulimall.search.thread;

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

public class ThreadTestAsyn {

    //创建线程池
    public static ExecutorService executor = Executors.newFixedThreadPool(10);
    
    public static void main(String[] args) throws Exception {
        //1、Async创建异步对象，没返回值
//        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
//            //异步任务内容
//            System.out.println("current thread: " + Thread.currentThread().getId());
//            int i = 10 / 2;
//            System.out.println("run result: " + i);
//        }, executor);

        //2、Supply，有返回值
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("current thread: " + Thread.currentThread().getId());
            int i = 10 / 0;
            System.out.println("run result: " + i);
            return i;
            //参数(结果，异常)，虽然能得到异常信息，但是没法修改返回数据
        }, executor).whenComplete((res,exception)->{
            System.out.println("async completed...result is: "+res+",exception is: "+exception);
        //如果结果出现异常，就给一个默认返回值，感知异常，同时返回默认值
        }).exceptionally((t)->{
            return 4;
        });
        //获取异步结果
        Integer integer = future.get();
        System.out.println(integer);
        System.out.println("main...end..");
    }
}

4、handle

可对结果做异常处理，可改变返回值

package com.lian.gulimall.search.thread;

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

public class ThreadTestAsyn {

    //创建线程池
    public static ExecutorService executor = Executors.newFixedThreadPool(10);
    public static void main(String[] args) throws Exception {
        //1、Async创建异步对象，没返回值
        //方法执行完成后得处理，无论成功与失败
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("current thread: " + Thread.currentThread().getId());
            int i = 10 / 4;
            System.out.println("run result: " + i);
            return i;
            //参数(结果，异常)，虽然能得到异常信息，但是没法修改返回数据
        }, executor).handle((res,thr)->{
            //如果返回结果不为空，就将结果×2
            if (res != null){
                return res*2;
            }
            //如果异常不为空，就返回0
            if (thr != null) {
                return 0;
            }
            //如果两个都不走就返回0
            return 0;
        });
        //获取异步结果
        Integer integer = future.get();
        System.out.println(integer);
    }
}

5、CompletableFuture线程串行化

在这里插入图片描述

1、thenRunAsync，`不能获取到上一步的执行结果，无返回值`

public class ThreadTestAsyn {

    //创建线程池
    public static ExecutorService executor = Executors.newFixedThreadPool(10);
    public static void main(String[] args) throws Exception {
    //thenRun 不能获取到上一步的执行结果，无返回值
        CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("current thread: " + Thread.currentThread().getId());
            int i = 10 / 4;
            System.out.println("run result: " + i);
            return i;
            //参数(结果，异常)，虽然能得到异常信息，但是没法修改返回数据
        }, executor).thenRunAsync(() -> {
            System.out.println("task2 startting");
        }, executor);
   }

2、thenAccept 能接收上一步的`执行结果`，但是`无返回值`

public class ThreadTestAsyn {

    //创建线程池
    public static ExecutorService executor = Executors.newFixedThreadPool(10);
    public static void main(String[] args) throws Exception {
   	    //thenAccept 能接收上一步的执行结果，但是无返回值
        CompletableFuture.supplyAsync(() -> {
            System.out.println("current thread: " + Thread.currentThread().getId());
            int i = 10 / 4;
            System.out.println("run result: " + i);
            return i;
            //参数(结果，异常)，虽然能得到异常信息，但是没法修改返回数据
        }, executor).thenAcceptAsync((res)->{
            System.out.println("task2 startting"+res);
        },executor);
   }

3、thenApply 既能接收上一步的`执行结果，还有返回值`

public class ThreadTestAsyn {

    //创建线程池
    public static ExecutorService executor = Executors.newFixedThreadPool(10);
    public static void main(String[] args) throws Exception {
    	//thenApply 既能接收上一步的执行结果，还有返回值
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("current thread: " + Thread.currentThread().getId());
            int i = 10 / 4;
            System.out.println("run result: " + i);
            return i;
            //参数(结果，异常)，虽然能得到异常信息，但是没法修改返回数据
        }, executor).thenApplyAsync((res) -> {
            System.out.println("task2 startting" + res);
            return "hello" + res;
        }, executor);
        System.out.println("main...end...."+future2.get());
    }

两任务组合-都要完成

在这里插入图片描述

public class ThreadTestAsyn {

    //创建线程池
    public static ExecutorService executor = Executors.newFixedThreadPool(10);
    public static void main(String[] args) throws Exception {
    	CompletableFuture<Integer> future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("task1 thread start: " + Thread.currentThread().getId());
            int i = 10 / 4;
            System.out.println("task1 end");
            return i;
        }, executor);

        CompletableFuture<String> future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("task2 thread start: " + Thread.currentThread().getId());
            System.out.println("task2 end");
            return "hello";
        }, executor);

        //组合两个future，不需要获取future的结果,只需两个future处理完任务后，处理该任务
        future01.runAfterBothAsync(future02,()->{
            System.out.println("task3 start...");
        },executor);

        //组合两个future，获取两个future任务的返回结果,然后处理任务，没有返回值
        future01.thenAcceptBothAsync(future02,(t,u)->{
            System.out.println("task3 start...，result is："+t+"--》"+u);
        },executor);

        //组合两个future，获取两个future任务的返回结果,并返回当前任务的返回值
        CompletableFuture<String> future = future01.thenCombineAsync(future02, (f1, f2) -> {
            return f1 + ":" + f2 + "--> haha";
        }, executor);
        System.out.println("main..end"+future.get());

    }

两任务组合-其中一个完成

在这里插入图片描述

public class ThreadTestAsyn {

    //创建线程池
    public static ExecutorService executor = Executors.newFixedThreadPool(10);
    public static void main(String[] args) throws Exception {

	CompletableFuture<Object> future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("task1 thread start: " + Thread.currentThread().getId());
            int i = 10 / 4;
            System.out.println("task1 end");
            return i;
        }, executor);

        CompletableFuture<Object> future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("task2 thread start: " + Thread.currentThread().getId());
            System.out.println("task2 end");
            return "hello";
        }, executor);

		//两个任务，只要有一个完成，就执行任务3，不感知结果，也没有返回值
        future01.runAfterEitherAsync(future02,()->{
            System.out.println("task3 start...");
        },executor);

        //只接收上一次任务的返回结果，没有返回值，感知结果，没有返回值
        future01.acceptEitherAsync(future02,(res)->{
            System.out.println("task3 start..."+res);
        },executor);

        //感知结果，也有返回值
        future01.applyToEitherAsync(future02,(res)->{
            System.out.println("task3 start..."+res);
            return res.toString() + "--> haha";
        },executor);
    }

多任务组合

在这里插入图片描述

public class ThreadTestAsyn {

    //创建线程池
    public static ExecutorService executor = Executors.newFixedThreadPool(10);
    public static void main(String[] args) throws Exception {
    CompletableFuture<String> futureImg = CompletableFuture.supplyAsync(() -> {
            System.out.println("product info");
            return "hello.jpg";
        }, executor);

        CompletableFuture<String> futureAttr = CompletableFuture.supplyAsync(() -> {
            System.out.println("product info");
            return "black 256g";
        }, executor);

        CompletableFuture<String> futureDes = CompletableFuture.supplyAsync(() -> {
            System.out.println("product info");
            return "huawei";
        }, executor);

        CompletableFuture<Void> future = CompletableFuture.allOf(futureImg, futureAttr, futureDes);
        future.get();  //get方法阻塞等待所有结果完成

        System.out.println(futureImg.get()+futureAttr.get()+futureDes.get());
    }

五、案例演示

在商品详情页时，为了提升效率，节省时间，采用异步编排方式

第1步、配置属性和类绑定赋值

package com.lian.gulimall.product.config;

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

@ConfigurationProperties(prefix = "gulimall.thread")
@Component
@Data
public class ThreadPoolConfigProperties {
    private Integer coreSize;      //核心线程数
    private Integer maxSize;       //最大线程数
    private Integer keepAliveTime; //存活时间
}

第2步、配置application.properties，给实体类赋值

gulimall.thread.core-size=20
gulimall.thread.max-size=200
gulimall.thread.keep-alive-time=10

第3步、自定义线程池

package com.lian.gulimall.product.config;

import org.springframework.boot.context.properties.EnableConfigurationProperties;
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;

/**
 * 自定义线程池
 * 注入到spring容器就不需要配置 自动导入配置属性注解了
 */
//@EnableConfigurationProperties(ThreadPoolConfigProperties.class)
@Configuration
public class MyThreadConfig {

    @Bean
    public ThreadPoolExecutor threadPoolExecutor(ThreadPoolConfigProperties pool){
        return new ThreadPoolExecutor(
                pool.getCoreSize(),
                pool.getMaxSize(),
                pool.getKeepAliveTime(),
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(10000),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
    }
}

第4步、商品详情页的控制层

package com.lian.gulimall.product.web;

import com.lian.gulimall.product.service.SkuInfoService;
import com.lian.gulimall.product.vo.SkuItemVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

/**
 * 详情页
 */
@Controller
public class ItemController {

    @Autowired
    SkuInfoService skuInfoService;

    /**
     * 展示当前sku的详情
     * @return
     */
    @GetMapping("/{skuId}.html")
    public String skuItem(@PathVariable("skuId") Long skuId, Model model) throws Exception{
        System.out.println("准备查询"+skuId+"的详情");
        //根据skuId查询到所有的属性都封装到 SkuItemVo 中
        SkuItemVo vos = skuInfoService.item(skuId);
        model.addAttribute("item",vos);
        return "item";
    }
}

第5步、业务层

@Service("skuInfoService")
public class SkuInfoServiceImpl extends ServiceImpl<SkuInfoDao, SkuInfoEntity> implements SkuInfoService {

	@Autowired
    SkuImagesService skuImagesService; //图片的sku

    @Autowired
    ProductAttrValueService productAttrValueService; //商品属性值

    @Autowired
    SpuInfoDescService spuInfoDescService; //商品描述

    @Autowired
    AttrGroupService attrGroupService;  //组信息

    @Autowired
    SkuSaleAttrValueService skuSaleAttrValueService;

    @Autowired
    ThreadPoolExecutor executor;   //注入线程池

	@Override
    public SkuItemVo item(Long skuId) throws Exception{
    
        //商品详情页返回数据都封装到 SkuItemVo
        SkuItemVo skuItemVo = new SkuItemVo();

        /**
         * 使用异步编排，节省时间提升效率，一起执行不阻塞等待
         * 第一种：supplyAsync 有返回值，其他任务可以用
         * 开启一个异步任务，创建异步对象
         * infoFuture 任务完成后，saleAttrFuture、descFuture、baseAttrFuture 才开始执行，因为他们都需要依赖任务1的数据结果
         */
        CompletableFuture<SkuInfoEntity> infoFuture = CompletableFuture.supplyAsync(() -> {
            //1、sku基本信息获取，标题、副标题、价格等 pms_sku_info
            SkuInfoEntity info = baseMapper.selectById(skuId);
            skuItemVo.setInfo(info);
            //因为其他任务要用基本信息，所以我们返回基本信息
            return info;
            //executor代表要放到自己的线程池里面
        }, executor);

        //第二种：接下来接收任务的返回结果,accept只是接收上一个任务的结果，自己不返回结果
        CompletableFuture<Void> saleAttrFuture = infoFuture.thenAcceptAsync((res) -> {
            //执行第二个任务
            //3、获取spu的销售属性组合
            List<SkuItemSaleAttrVo> saleAttrVos = skuSaleAttrValueService.getSaleAttrsBySpuId(res.getSpuId());
            skuItemVo.setSaleAttr(saleAttrVos);
        });

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

        //继续执行任务，任务3、4、5都依赖任务1的结果 获取spuId
        CompletableFuture<Void> baseAttrFuture = infoFuture.thenAcceptAsync((res) -> {
            //5、获取spu的规格参数信息
            List<SpuItemAttrGroupVo> attrGroupVos = attrGroupService.getAttrGroupWithAttrsBySpuId(res.getSpuId(), res.getCatalogId());
            skuItemVo.setGroupAttrs(attrGroupVos);
        }, executor);

        /**
         * 任务2 不需要依赖任务1提供的结果数据，所以不需要等待任务1完成，直接和任务1同步执行，所以自己也开启一个异步任务
         * runAsync 代表不需要返回结果，因为也没有其他任务需要依赖任务2的数据
         */
        CompletableFuture<Void> imageFuture = CompletableFuture.runAsync(() -> {
            //2、sku图片信息 pms_sku_images
            List<SkuImagesEntity> images = skuImagesService.getImagesBySkuId(skuId);
            skuItemVo.setImages(images);
        }, executor);

        /**
         * 等待所有任务都完成，因为每一个任务都是在给 vo 中封装数据
         * get()方法就是阻塞等待所有任务都执行完
         * infoFuture 也可以不写，因为别人是依赖她的，如果别人都执行完了，那么她肯定也执行完了
         */
        CompletableFuture.allOf(infoFuture, saleAttrFuture, descFuture, baseAttrFuture, imageFuture).get();

        return skuItemVo;
    }

廉小雨

关注

1
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
异步ComplatableFuture

1、创建线程的4种方式继承Thread类public class ThreadTest { public static void main(String[] args) { Thread01 thread01 = new Thread01(); new Thread(thread01).start(); } public static class Thread01 extends Thread{ @Override
复制链接

扫一扫