CompletableFuture 异步编排

多线程任务编排:CompletableFuture从入门到精通 我们把Runnable理解为最基本的,只具备在线程下执行一段逻辑的能力。为了获取执行的返回值,创造了Callable和与其配合使用的Future。为了将任务之间进行逻辑编排,就诞生了CompletableFuture。关于如何理解任务的逻辑编排,举一个简单的例子:打开电脑-更新系统这两个操作是有先后顺序的,但是泡茶和这两个操作没有先后顺序,是可以并行的,而开始办公必须要等待其他操作结束之后才能进行,这就形成了任务编排的执行链。在IO密集型系统中,类似的场景有很多。 阅读详情

前言

在 Java8 中,新增了 CompletableFuture 异步编程工具类。它与我们之前使用的 Future 接口有何区别呢?本文将对这个重要的 CompletableFuture 类进行分析学习。

一、Future 接口及改进

Future 接口(FutureTask 实现类),定义了操作异步任务执行的一些方法。例如获取异步任务的执行结果、取消任务的执行、判断任务是否被取消、判断任务执行是否完毕等方法。

Modifier and TypeMethodDescription
booleancancel(boolean mayInterruptIfRunning)尝试取消执行此任务。
Vget()等待计算完成,然后检索其结果。
Vget(long timeout, TimeUnit unit)如果需要等待最多在给定的时间计算完成,然后检索其结果(如果可用)。
booleanisCancelled()如果此任务在正常完成之前被取消,则返回 true 。
booleanisDone()返回 true 如果任务已完成。

我们通常使用 Future 接口进行异步编程时,获取结构都需要阻塞获取。主线程中会阻塞,其实更好的结果是让它执行完结果后通知我们获取。

总结:future 接口可以为主线程开一个分支任务,专门为主线程处理耗时和费力的复杂业务。

1.1 FutureTask 简介

由关系图可以看到,FutureTask 除了实现 Future 接口外,还实现了 Runnable 接口,因此,FutureTask 可以交给 Executor 执行。也可以由调用线程执行执行 FutureTask.run() 方法。

入门案例:

public class FutureTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        FutureTask<String> stringFutureTask = new FutureTask<>(new MyThread2());
        Thread thread = new Thread(stringFutureTask);
        thread.start();

        String s = stringFutureTask.get();
        System.out.println(s);
    }
}

class MyThread2 implements Callable<String>{

    @Override
    public String call() throws Exception {
        System.out.println("come in");
        return "hello";
    }
}
// come in
// hello

future + 线程池异步多线程任务配合,能显著提高程序的执行效率。

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        ExecutorService threadPool = Executors.newFixedThreadPool(3);
        FutureTask<String> stringFutureTask = new FutureTask<String>(()->{
            TimeUnit.MICROSECONDS.sleep(500);
            return "aaa";
        });
        threadPool.submit(stringFutureTask);
        FutureTask<String> stringFutureTask2 = new FutureTask<String>(()->{
            TimeUnit.MICROSECONDS.sleep(300);
            return "bbb";
        });
        threadPool.submit(stringFutureTask2);
        TimeUnit.MICROSECONDS.sleep(300);
        threadPool.shutdown();
    }

注意:

  • 1、futureTask.get() 会造成阻塞,一般建议放在程序后面,不管你是否计算完成,容易造成程序阻塞。
  • 2、假如不愿意等待很长时间,可以加个到期时间,过期不候。stringFutureTask.get(10,TimeUnit.SECONDS);

1.2 异步获取

如果不想阻塞主线程,异步获取结果,通常会以轮询的方式获取结果,不会造成主线程的阻塞,但是轮询的方式会耗费 CPU 资源,调用 isDone() 进行轮询。

public class CompletableFutureDemo2 {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String> futureTask = new FutureTask<>(() -> {
            System.out.println("-----come in FutureTask");
            try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
            return ""+ ThreadLocalRandom.current().nextInt(100);
        });

        new Thread(futureTask,"t1").start();

        System.out.println(Thread.currentThread().getName()+"\t"+"线程完成任务");

        /**
         * 用于阻塞式获取结果,如果想要异步获取结果,通常都会以轮询的方式去获取结果
         */
        while (true){
            if(futureTask.isDone()){
                System.out.println(futureTask.get());
                break;
            }
        }
    }
}


总结:

  • future 对于结果的获取不是很友好,只能通过阻塞或轮询的方式得到任务的结果’

1.3 对 Future 接口的改进

1.3.1 CompletableFuture 类

虽然,Future 接口提供了异步任务的能力,但是对于结果的获取非常不方便,阻塞的方式违背了异步编程的初衷,轮询的方式又会耗费无谓的 CPU 资源,且不能及时的得到计算结果,为什么不能使用观察者设计模式当计算结果完成及时通知监听者呢?

很多语言,比如 Node.js 采用回调的方式实现异步编程。 Java 的一些框架,比如 Netty,也提供了通用的扩展 Future,而作为正统的 Java 类库,Java8 新增了一个包含 50 个方法左右的类 ==> CompletableFuture。提供了非常强大的 Future 扩展功能,提供了函数式编程的能力,可以通过回调的方式处理计算结果。

它实现了 future 和 completionStage 两个接口。 提供了观察者模式,可以让任务执行完成后通知监听的一方。

  • 异步任务结束时,会自动回调某个方法
  • 主线程设置回调后,不再关心异步任务的执行,异步任务之间可以顺序执行。
  • 异步任务出错,会自动回调某个对象的方法

1.3.2 CompletionStage

代表异步计算过程的某一阶段,一个阶段完成以后可能会触发另外一个阶段,有些类似 Linux 系统的管道分隔符传参数。 一个阶段的执行可能是被单个阶段的完成触发,也可能是由多个阶段一起触发

CompletionStage 的接口方法可以从多种角度进行分类,从最宏观的横向划分,CompletionStage 的接口主要分为三类:

  • 供给型 : 就是用上一个阶段的结果作为指定函数的参数执行函数产生新的结果。这一类接口方法名中基本都有 apply字样。
  • 消耗型:就是用上一个阶段的结果作为指定操作,但不对阶段结果产生影响。这一类接口方法名中基本都有 accept 字样。
  • 不消耗不产出:就是不依据上一个阶段的执行结果,主要上一个阶段完成,就执行指定的操作,且不对阶段的结果产生影响,基本都有 run 字样。

CompletionStage接口定义了任务编排的方法,执行某一阶段,可以向下执行后续阶段。异步执行的,默认线程池是ForkJoinPool.commonPool(),但为了业务之间互不影响,且便于定位问题,强烈推荐使用自定义线程池。

二、使用介绍

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

public static CompletableFuture<Void> runAsync(Runnable runnable)
public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor)
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor)

  • 1、runXxx 都是没有返回结果的,supplyXxx 都是可以获取返回值的;
  • 2、可以传入自定义的线程池,否则就用默认的线程池:ForkJoinPool.commonPool() ;
  • 3、Async 代表异步的意思。

2.1 获得结果和触发计算

  • 获得结果
    • get() :不见不散
    • get(long timeout, TimeUnit unit):过时不候
    • join():约等于get,不会抛出异常
    • getNow(T valueIfAbsent):立即获得结果,计算完返回计算的结果,否则返回设定的指。
public class CompletableFutureDemo2{
    public static void main(String[] args) throws ExecutionException, InterruptedException{
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
            try { TimeUnit.SECONDS.sleep(1); } 
            catch (InterruptedException e) { e.printStackTrace(); }
            return 533;
        });

        //去掉注释上面计算没有完成,返回444
        //开启注释上面计算完成,返回计算结果
        try { TimeUnit.SECONDS.sleep(2); } 
        catch (InterruptedException e) { e.printStackTrace(); }

        System.out.println(completableFuture.getNow(444));
    }
}

public class CompletableFutureDemo2{
    public static void main(String[] args) throws ExecutionException, InterruptedException{
        System.out.println(CompletableFuture.supplyAsync(() -> "abc")
        .thenApply(r -> r + "123").join());
    }
}   

  • 主动触发计算

打断 get 方法立即获得返回括号值。

// 是否打断get方法立即返回括号值
public boolean complete(T value)

public class CompletableFutureDemo4{
    public static void main(String[] args) throws ExecutionException, InterruptedException{
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
            return 533;
        });

        //注释掉暂停线程,get还没有算完只能返回complete方法设置的444;暂停2秒钟线程,异步线程能够计算完成返回get
        try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }

        //当调用CompletableFuture.get()被阻塞的时候,complete方法就是结束阻塞并get()获取设置的complete里面的值.
        System.out.println(completableFuture.complete(444)+"\t"+completableFuture.get());
    }
}   

2.2 对计算结果进行处理

2.2.1 thenApply

计算结果存在依赖关系,这两个线程串行化,由于依赖关系,当前步骤有异常就叫停,主线程如果结束,默认线程池就会关闭。

public class CompletableFutureDemo4{
    public static void main(String[] args) throws ExecutionException, InterruptedException{
        //当一个线程依赖另一个线程时用 thenApply 方法来把这两个线程串行化,
        CompletableFuture.supplyAsync(() -> {
            //暂停几秒钟线程
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println("111");
            return 1024;
        }).thenApply(f -> {
            System.out.println("222");
            return f + 1;
        }).thenApply(f -> {
            //int age = 10/0; // 异常情况:那步出错就停在那步。
            System.out.println("333");
            return f + 1;
        }).whenCompleteAsync((v,e) -> {
            System.out.println("*****v: "+v);
        }).exceptionally(e -> {
            e.printStackTrace();
            return null;
        });

        System.out.println("-----主线程结束,END");

        // 主线程不要立刻结束,否则CompletableFuture默认使用的线程池会立刻关闭:
        try { TimeUnit.SECONDS.sleep(2); } 
        catch (InterruptedException e) { e.printStackTrace(); }
    }   
}  

2.2.2 handle

有异常也可以往下一步走,根据带的异常可以进一步处理。

// 有异常也可以往下一步走,根据带的异常参数可以进一步处理
public class CompletableFutureDemo4{

    public static void main(String[] args) throws ExecutionException, InterruptedException{
        //当一个线程依赖另一个线程时用 handle 方法来把这两个线程串行化,
        // 异常情况:有异常也可以往下一步走,根据带的异常参数可以进一步处理
        CompletableFuture.supplyAsync(() -> {
            //暂停几秒钟线程
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println("111");
            return 1024;
        }).handle((f,e) -> {
            int age = 10/0;
            System.out.println("222");
            return f + 1;
        }).handle((f,e) -> {
            System.out.println("333");
            return f + 1;
        }).whenCompleteAsync((v,e) -> {
            System.out.println("*****v: "+v);
        }).exceptionally(e -> {
            e.printStackTrace();
            return null;
        });

        System.out.println("-----主线程结束,END");

        // 主线程不要立刻结束,否则CompletableFuture默认使用的线程池会立刻关闭:
        try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }
    }
}   

2.3 对于结算结果进行消费

与结果处理和结果转换犀利函数返回一个新的 CompletableFuture 不同,结果消费系列函数只对结果执行 Action,而不返回新的计算值。 根据对结果的处理方式,结果消费函数又可以分为三大类:

  • thenAccept():对单个结果进行消费
  • thenAcceptBoth():对两个结果进行消费
  • thenRun():不关心结果,只对结果执行 Action

2.3.1 thenAccept

观察该函数的参数类型可知,它们是函数式接口 Consumer,这个接口就只有输入,没有返回值。 常用方法:

public CompletionStage<Void> thenAccept(Consumer<? super T> action);
public CompletionStage<Void> thenAcceptAsync(Consumer<? super T> action);

任务A 执行完执行 B,B 需要 A 的结果,但是任务 B 无返回值。

CompletableFuture<Void> future = CompletableFuture
    .supplyAsync(() -> {
        int number = new Random().nextInt(10);
        System.out.println("第一次运算:" + number);
        return number;
    }).thenAccept(number ->
                  System.out.println("第二次运算:" + number * 5));

2.3.2 thenAcceptBoth

这个函数的作用是,当两个 CompletionStage 都正常完成计算的时候,就会执行提供的 action 消费两个异步的结果。

具体使用:

CompletableFuture<Integer> futrue1 = CompletableFuture.supplyAsync(new Supplier<Integer>() {
    @Override
    public Integer get() {
        int number = new Random().nextInt(3) + 1;
        try {
            TimeUnit.SECONDS.sleep(number);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("任务1结果:" + number);
        return number;
    }
});

CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(new Supplier<Integer>() {
    @Override
    public Integer get() {
        int number = new Random().nextInt(3) + 1;
        try {
            TimeUnit.SECONDS.sleep(number);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("任务2结果:" + number);
        return number;
    }
});

futrue1.thenAcceptBoth(future2, new BiConsumer<Integer, Integer>() {
    @Override
    public void accept(Integer x, Integer y) {
        System.out.println("最终结果:" + (x + y));
    }
});

2.3.3 thenRun

thenRun 也是对线程任务结果的一种消费函数,与 thenAccept 不同的是,thenRun 会在上一阶段 Runable。

任务A 执行完 B,并且 B 不需要 A 的结果。

常用方法:

public CompletionStage<Void> thenRun(Runnable action);
public CompletionStage<Void> thenRunAsync(Runnable action);

具体使用:

CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
    int number = new Random().nextInt(10);
    System.out.println("第一阶段:" + number);
    return number;
}).thenRun(() ->
           System.out.println("thenRun 执行"));

2.4 对计算速度进行选用

线程交互指将两个线程任务获取结果的速度相对比较,按一定的规则进行下一步处理。

2.4.1 applyToEither

一句话:谁快用谁。

两个线程任务相比较,先获得执行结果的,就对该结果进行下一步的转化操作。两个任务有一个执行完成,获取它的返回值,处理任务并有新的返回值。

常用方法:

public <U> CompletionStage<U> applyToEither(CompletionStage<? extends T> other,Function<? super T, U> fn);
public <U> CompletionStage<U> applyToEitherAsync(CompletionStage<? extends T> other,Function<? super T, U> fn);

具体使用:

public class CompletableFutureDemo5{
    public static void main(String[] args) throws ExecutionException, InterruptedException{
        CompletableFuture<Integer> completableFuture1 = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "\t" + "---come in ");
            //暂停几秒钟线程
            try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }
            return 10;
        });

        CompletableFuture<Integer> completableFuture2 = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "\t" + "---come in ");
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
            return 20;
        });

        CompletableFuture<Integer> thenCombineResult = completableFuture1.applyToEither(completableFuture2,f -> {
            System.out.println(Thread.currentThread().getName() + "\t" + "---come in ");
            return f + 1;
        });

        System.out.println(Thread.currentThread().getName() + "\t" + thenCombineResult.get());
    }
}

2.4.2 acceptEither

两个线程任务相比较,先获得执行结果的,就对该结果进行下一步的消费操作。两个任务有一个执行完成,获取它的返回值,处理任务,没有新的返回值。

常用方法:

public CompletionStage<Void> acceptEither(CompletionStage<? extends T> other,Consumer<? super T> action);
public CompletionStage<Void> acceptEitherAsync(CompletionStage<? extends T> other,Consumer<? super T> action);

具体使用:

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(new Supplier<Integer>() {
    @Override
    public Integer get() {
        int number = new Random().nextInt(10) + 1;
        try {
            TimeUnit.SECONDS.sleep(number);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("第一阶段:" + number);
        return number;
    }
});

CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(new Supplier<Integer>() {
    @Override
    public Integer get() {
        int number = new Random().nextInt(10) + 1;
        try {
            TimeUnit.SECONDS.sleep(number);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("第二阶段:" + number);
        return number;
    }
});

future1.acceptEither(future2, new Consumer<Integer>() {
    @Override
    public void accept(Integer number) {
        System.out.println("最快结果:" + number);
    }
});

2.4.3 runAfterEither

两个任务有一个执行完成,不需要获取 future 的结果,处理任务,也没有返

回值。

常用方法:

public CompletionStage<Void> runAfterEither(CompletionStage<?> other,Runnable action);
public CompletionStage<Void> runAfterEitherAsync(CompletionStage<?> other,Runnable action);

具体使用:

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(new Supplier<Integer>() {
    @Override
    public Integer get() {
        int number = new Random().nextInt(5);
        try {
            TimeUnit.SECONDS.sleep(number);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("任务1结果:" + number);
        return number;
    }
});

CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(new Supplier<Integer>() {
    @Override
    public Integer get() {
        int number = new Random().nextInt(5);
        try {
            TimeUnit.SECONDS.sleep(number);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("任务2结果:" + number);
        return number;
    }
});

future1.runAfterEither(future2, new Runnable() {
    @Override
    public void run() {
        System.out.println("已经有一个任务完成了");
    }
}).join();

2.5 对计算结果进行合并

2.5.1 两个任务都要完成

  • thenCombine:组合两个 future,获取两个 future 的返回结果,并返回当前任务的返回值

  • thenAcceptBoth:组合两个 future,获取两个 future 任务的返回结果,然后处理任务,没有返回值。

  • runAfterBoth:组合两个 future,不需要获取 future 的结果,只需两个 future 处理完任务后,处理该任务


CompletableFuture<Integer> future1 = CompletableFuture
    .supplyAsync(new Supplier<Integer>() {
        @Override
        public Integer get() {
            int number = new Random().nextInt(10);
            System.out.println("任务1结果:" + number);
            return number;
        }
    });
CompletableFuture<Integer> future2 = CompletableFuture
    .supplyAsync(new Supplier<Integer>() {
        @Override
        public Integer get() {
            int number = new Random().nextInt(10);
            System.out.println("任务2结果:" + number);
            return number;
        }
    });
CompletableFuture<Integer> result = future1
    .thenCombine(future2, new BiFunction<Integer, Integer, Integer>() {
        @Override
        public Integer apply(Integer x, Integer y) {
            return x + y;
        }
    });
System.out.println("组合后结果:" + result.get());

2.5.2 多任务组合

  • allOf:等待所有任务完成
Random random = new Random();
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
    try {
        TimeUnit.SECONDS.sleep(random.nextInt(5));
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return "hello";
});

CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
    try {
        TimeUnit.SECONDS.sleep(random.nextInt(1));
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return "world";
});
CompletableFuture<Object> result = CompletableFuture.anyOf(future1, future2);

  • anyOf:只要有一个任务完成
public static void main(String[] args) {
    List<CompletableFuture> futures = Arrays.asList(CompletableFuture.completedFuture("hello"),
                                                    CompletableFuture.completedFuture(" world!"),
                                                    CompletableFuture.completedFuture(" hello"),
                                                    CompletableFuture.completedFuture("java!"));
    final CompletableFuture<Void> allCompleted = CompletableFuture.allOf(futures.toArray(new CompletableFuture[]{}));
    allCompleted.thenRun(() -> {
        futures.stream().forEach(future -> {
            try {
                System.out.println("get future at:"+System.currentTimeMillis()+", result:"+future.get());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        });
    });
}

测试结果:

get future at:1568892339473, result:hello
get future at:1568892339473, result: world!
get future at:1568892339473, result: hello
get future at:1568892339473, result:java!

三、案例

场景:例如查询商品详情页面的逻辑比较复杂

// 1\. 获取sku的基本信息   0.5s

// 2\. 获取sku的图片信息   0.5s

// 3\. 获取sku的促销信息 TODO 1s

// 4\. 获取spu的所有销售属性 1s

// 5\. 获取规格参数组及组下的规格参数 TODO 1.5s

// 6\. spu详情 TODO   1s

.........

那么一步步的执行下去,用户需要6.5秒后才能看到详情页的内容,很显然不能接受的,如果有多个线程同时完成这6步操作,也许只需要 1.5s 即可完成内容。

    @Override
    public SkuItemVo item(Long skuId) throws ExecutionException, InterruptedException {
        SkuItemVo skuItemVo = new SkuItemVo();

        CompletableFuture<SkuInfoEntity> infoFuture = CompletableFuture.supplyAsync(() -> {
            //1、sku基本信息的获取  pms_sku_info
            SkuInfoEntity info = this.getById(skuId);
            skuItemVo.setInfo(info);
            return info;
        }, executor);

        CompletableFuture<Void> saleAttrFuture = infoFuture.thenAcceptAsync((res) -> {
            //3、获取spu的销售属性组合
            List<SkuItemSaleAttrVo> saleAttrVos = skuSaleAttrValueService.getSaleAttrBySpuId(res.getSpuId());
            skuItemVo.setSaleAttr(saleAttrVos);
        }, executor);

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

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

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

        CompletableFuture.allOf(saleAttrFuture,descFuture,baseAttrFuture,imageFuture,seckillFuture).get();
        return skuItemVo;
    }
简述CompletableFuture异步任务编排 在之前的项目开发中,都没怎么使用过CompletableFuture的功能,只听说过和异步编程有关。为了能够在将来有需要的时候用得上,这两天花了点时间学习了一下,并简单地总结一下如何使用CompletableFuture完成异步任务编排。​@Override// 设置为守护线程,main线程结束就跟着一起结束,否则main函数结束jvm还在return t;}复制代码。 阅读详情

相关推荐

CompletableFuture实现异步编排

为什么需要异步执行?①获取商品基本信息 ②获取商品图片信息 ③获取商品促销活动信息 ④获取商品各种类的基本信息等操作,如果使用串行方式去执行这些操作,假设每个操作执行1s,那么用户看到完整的商品详情就需要4s的时间,如果使用并行方式执行这些操作,可能只需要1s就可以完成。所以这就是异步执行的好处。JDK5的Future接口Future接口用于代表异步计算的结果,通过Future接口提供的方法可以查看异步计算是否执行完成,或者等待执行结果并获取执行结果,同时还可以取消执行。列举Futureget()

m0_73311735的博客 315

CompletableFuture任务编排

多线程、CompletableFuture任务编排

囚徒之困 1032

70 CompletableFuture异步编排

在企业级开发中,传统的接口存在诸多局限性,而提供了强大的异步编程能力:传统Future的痛点:CompletableFuture的优势:典型应用场景:并行查询多个数据源 批量异步处理 复杂业务流程编排 超时控制与降级 CompletableFuture与Future的对比 传统Future代码: CompletableFuture代码: CompletableFuture状态机 CompletableFuture内部维护三种状态: 2 runAsync - 无返回值异步执行 2.1 核心原

云上凯歌 41

异步编排-CompletableFuture

一、CompletableFuture 异步编排 1、业务场景 ​ 查询商品详情页的逻辑比较复杂,有些数据还需要远程调用,必然需要花费更多的时间。 假如商品详情页的每个查询,需要如下标注的时间才能完成 那么,用户需要 5.5s 后才能看到商品详情页的内容。很显然是不能接受的。 如果有多个线程同时完成这 6 步操作,也许只需要 1.5s 即可完成响应。 2、java8 - CompletableFuture 在 Java 8 中, 新增加了一个包含 50 个方法左右的类: CompletableFutur

java123456111的博客 3588

3个国产AI大模型实战:如何用DeepSeek+豆包+千问批量生成高质量测试用例(附完整代码)

本文详细介绍了如何利用DeepSeek、豆包和千问三大国产AI大模型批量生成高质量测试用例的实战方法。通过Python环境配置、多模型SDK安装和统一接口封装,实现高效测试用例生成,并结合结构化提示词设计和多模型结果对比分析,显著提升测试效率和覆盖率。

weixin_29197699的博客 714

如何实现MCGS与S7-200SMART PLC以太网多台通信控制?

第九步:(设备工具箱—设备管理—鼠标依次点击通用TCP/IP父设备—西门子_ Smart200到设备窗口里面去)数据类型:第0位(指PLC地址变量小数点后面的位数,例如我地址是M0.0,那么在数据类型应填写通道的第00位)第十步:(鼠标双击打开通用TCPIP父设备0--[通用TCP/IP父设备]进入通信配置)通道地址:0(指小数点前面起始字节的地址,例如我地址是M0.0,那么应在通道地填写0)。第七步:(选择通用TCP/IP父设备,点击新增,右侧选定设备就会自动添加进去。

u010670857的博客 6720

CompletableFuture异步编排+实战

Future是Java 5添加的类,用来描述一个异步计算的结果。你可以使用isDone方法检查计算是否完成,或者使用get阻塞住调用线程,直到计算完成返回结果,你也可以使用cancel方法停止任务的执行。在Java 8中, 新增加了一个包含50个方法左右的类: CompletableFuture,提供了非常强大的Future的扩展功能,可以帮助我们简化异步编程的复杂性,提供了函数式编程的能力,可以通过回调的方式处理计算结果,并且提供了转换和组合CompletableFuture的方法。

Knight 2229

C++ muduo网络库知识分享01 - Linux平台下muduo网络库源码编译安装

Muduo is a multithreaded C++ network library based on the reactor pattern. muduo库的介绍就是:一个基于reactor反应堆模型的多线程C++网络库。 muduo网络库是C++语言开发的一个非常优秀的网络库,作者陈硕,muduo网络库在多线程环境下性能非常高,该系列文章会分享一些muduo库源码的知识,包括它的线程池源码...

大秦坑王的专栏 3万+

CompletableFuture异步编排

Future是Java 5添加的类,用来描述一个异步计算的结果。你可以使用isDone方法检查计算是否完成,或者使用get阻塞住调用线程,直到计算完成返回结果,你也可以使用cancel方法停止任务的执行。在Java 8中, 新增加了一个包含50个方法左右的类:,提供了非常强大的Future的扩展功能,可以帮助我们简化异步编程的复杂性,提供了函数式编程的能力,可以通过回调的方式处理计算结果,并且提供了转换和组合的方法。类实现了Future接口,所以你还是可以像以前一样通过get。

冲出仁川,走出马德里,故事还会再继续 1680

【我的Android进阶之旅】Android自定义View实现一个游戏摇杆,来实现监听遥动的方向或者监听摇动的角度的功能

一、需求描述 去年有个需求,需要使用自定义View实现一个游戏摇杆,来识别上下左右摇动的方向。 有点类似下面这样的王者荣耀游戏摇杆的效果 二、业界已有的参考资料 在下面这篇博客介绍了如何自定义游戏摇杆 2.1 博客介绍 Android自定义摇杆 2.1.1 功能 支持自适应大小 支持2个方向、4个方向、8个方向的摇动监听 支持摇动角度获取 可选回调模式 支持可摇动区域自定义 支持摇杆自定义 支持设置图片、色值、Shape图形 2.1.2 效果图 2.1.3 设置回调方式 setCallBac

字节卷动 1412

HTML爱心字母雨(完整代码)

HTML语言实现爱心字母雨的完整代码。

AIGC 2万+

CompletableFuture异步编排类详解

这篇文章简洁明了的介绍了CompletableFuture异步编程类,帮助大家快速入门。

2301_76827227的博客 1013

将 SAP BTP ABAP environment 与 SAP S/4HANA Cloud 公有云版集成:从架构理念到落地实战

本文探讨了在SAP云环境中实现ABAP扩展应用与S/4HANA Cloud系统集成的技术方案。通过建立标准化的远程通信通道,开发者可在SAP BTP ABAP环境中开发扩展应用,同时安全访问S/4HANA Cloud的核心业务数据和服务。文章详细介绍了整体架构设计、开发实现步骤(包括定义通信场景、生成服务消费模型和编写调用代码)以及管理员在S/4HANA侧的配置工作(创建通信安排和技术用户)。通过一个业务伙伴自助注册平台的案例,展示了如何在不修改标准系统的情况下实现云扩展,体现了SAP"干净核心&

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 245

ThreadPoolExecutor线程池与CompletableFuture线程异步编排

ThreadPoolExecutor线程池与CompletableFuture线程异步编排

zyxzyx666的博客 2306

卫朋:IPD流程落地之产品开发验证阶段解读

IPD验证阶段

产品线负责人 1490

PMP–一、二、三模–分类–13.干系人管理

A:确认是否已制定沟通管理计划,使业务干系人认识到项目的成功之处。B:让业务干系人参加冲刺回顾会议。C:与发起人和关键干系人一起确定产品待办事项列表中的优先要务,以便交付商业利益。D:为关键干系人开展收尾调研。C。

stqer的博客 1418

CompletableFuture异步编排,你还不会?

对于不需要返回结果的任务,使用runAsync。对于需要返回结果的任务,使用。在任务完成后,无论是否成功,都要执行某些操作时,使用或。仅在任务发生异常时处理异常并提供替代结果,使用。处理任务结果但不返回新值时,使用thenAccept。处理任务结果并返回新值时,使用thenApply或。根据是否需要异步执行选择同步或异步版本。带Async代表异步,异步就是启动另外线程去执行。有xxpply的就代表有返回值java代码解读复制代码。

Maisucsdn的博客 418

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

使用CompletableFuture异步编排

异步编排可以很好的利用cpu的并行计算资源,缩短单线程任务的耗时,CompletableFuture优点可以总结如下:通过异步执行任务,可以充分利用多核CPU的优势,提高程序的吞吐量和响应速度。CompletableFuture提供了丰富的API,使得异步编程更加简单和直观,减少了回调地狱(Callback Hell)的问题。可以使用thenApply、thenCompose等方法对任务结果进行处理,还可以使用thenCombine等方法组合多个任务,编排十分灵活。

PleaseBeStrong的博客 430

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

CompletableFuture实现异步编排全面分析和总结

结合了Future的优点,提供了非常强大的Future的扩展功能,可以帮助我们简化异步编程的复杂性,提供了函数式编程的能力,可以通过回调的方式处理计算结果,并且提供了转换和组合的方法。被设计在Java中进行异步编程。异步编程意味着在主线程之外创建一个独立的线程,与主线程分隔开,并在上面运行一个非阻塞的任务,然后通知主线程进展,成功或者失败。是由Java8引入的,在Java8之前我们一般通过Future实现异步。Future。

Java技术攻略的博客 3341

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

Java中CompletableFuture多线程任务异步编排

今天来简单看一下CompletableFuture多线程任务异步编排 为什么需要CompletableFuture? 当多线程任务出现了相互依赖,需要按照一定的顺序执行的时候就需要用到CompletableFuture多线程任务异步编排 按照我的理解:CompletableFuture可以分为一下几种情况 1、单任务 2、两任务的编排 3、三任务的编排 4、多任务的编排 ...

曹举的个人博客 4170

线程基础和CompletableFuture异步编排

程基础和CompletableFuture异步编排

m0_62946761的博客 2572
上一篇: Java8新特性Lambda表达式详解
下一篇: 总结近期腾讯+阿里+百度Java岗高频面试题,提问率高达98%
Java技术那些事儿
博客等级 码龄5年 2306粉丝 2584原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值