CompletableFuture异步编排(2)

最新推荐文章于 2024-06-16 18:48:44 发布
最新推荐文章于 2024-06-16 18:48:44 发布
阅读量529 收藏 2
点赞数
分类专栏： 异步 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41596346/article/details/122519171
版权

1.handle

public <U> CompletableFuture<U> handle( BiFunction<? super T, Throwable, ? extends U> fn);
public <U> CompletableFuture<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn);
public <U> CompletableFuture<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn, Executor executor);

和 complete 一样，可对结果做最后的处理（可处理异常），可改变返回值

package com.atguigu.gulimall.search.thread;

import java.util.concurrent.*;

/**
 * 异步编排CompletableFuture(计算完成时回调方法)
 * @author zfh
 * @email hst1406959716@163.com
 * @date 2022-01-04 09:48:36
 */
public class CompletableFutureDemo2 {
    public static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
            5,100,10,
            TimeUnit.SECONDS,new LinkedBlockingDeque<>(1000),
            Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main......start.....");

        /**
         * 方法完成后的感知
         */
//        CompletableFuture<Integer> integerCompletableFuture = CompletableFuture.supplyAsync(() -> {
//            System.out.println("当前线程：" + Thread.currentThread().getId());
//            int i = 10 / 0;
//            System.out.println("运行结果：" + i);
//            return i;
//        }, threadPoolExecutor).whenComplete((res,exception)->{
//            //能感知异常,但不能修改返回数据
//            System.out.println("异步任务成功完成啦....结果是:" + res + ";异常是:" + exception);
//        }).exceptionally(throwable -> {
//            //能感知异常,能修改返回数据(作为默认值)
//            return 10;
//        });

        /**
         * handle:方法执行完成后的处理
         */
        CompletableFuture<Integer> integerCompletableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 0;
            System.out.println("运行结果：" + i);
            return i;
        }, threadPoolExecutor).handle((res,throwable)->{
            if(res != null){
                return res * 10;
            }
            if(throwable != null){
                return 0;
            }
            return 10;
        });

        Integer integer = integerCompletableFuture.get();
        System.out.println("main......end......." + integer);
    }
}

在这里插入图片描述

2.线程串行化方法

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);
  • thenApply 方法：当一个线程依赖另一个线程时，获取上一个任务返回的结果，并返回当前任务的返回值。
  • thenAccept 方法：消费处理结果。接收任务的处理结果，并消费处理，无返回结果。
  • thenRun 方法：只要上面的任务执行完成，就开始执行 thenRun，只是处理完任务后，执行thenRun 的后续操作
  • 带有 Async 默认是异步执行的,以上都要前置任务成功完成
    Function<? super T,? extends U> T：上一个任务返回结果的类型 U：当前任务的返回值类型

2.1.thenRunAsync

不能获取到上一步执行的结果,无返回值

package com.atguigu.gulimall.search.thread;

import java.util.concurrent.*;

/**
 * 异步编排CompletableFuture(线程串行化方法)
 * @author zfh
 * @email hst1406959716@163.com
 * @date 2022-01-04 10:00:36
 */
public class CompletableFutureDemo3 {
    public static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
            5,20,10,
            TimeUnit.SECONDS,new LinkedBlockingDeque<>(1000),
            Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main......start.....");

        /**
         * 线程串行化
         * 1.thenRunXXX: 不能获取到上一步执行的结果,无返回值
         */
        CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果：" + i);
            return i;
        }, threadPoolExecutor).thenRunAsync(() -> {
            System.out.println("任务2启动.................");
        }, threadPoolExecutor);
        System.out.println("main......end......." );
    }
}

在这里插入图片描述

2.2.thenAcceptAsync

能获取到上一步执行的结果,无返回值

package com.atguigu.gulimall.search.thread;

import java.util.concurrent.*;

/**
 * 异步编排CompletableFuture(线程串行化方法)
 * @author zfh
 * @email hst1406959716@163.com
 * @date 2022-01-04 10:00:36
 */
public class CompletableFutureDemo3 {
    public static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
            5,20,10,
            TimeUnit.SECONDS,new LinkedBlockingDeque<>(1000),
            Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main......start.....");

        /**
         * 线程串行化
         * 2.thenAcceptXXX: 能获取到上一步执行的结果,无返回值
         */
        CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果：" + i);
            return i;
        }, threadPoolExecutor).thenAcceptAsync(res -> {
            System.out.println("任务2启动..............." + res);
        },threadPoolExecutor);
        System.out.println("main......end......." );
    }
}

在这里插入图片描述

2.3.thenApplyAsync

能获取到上一步执行的结果,有返回值

package com.atguigu.gulimall.search.thread;

import java.util.concurrent.*;

/**
 * 异步编排CompletableFuture(线程串行化方法)
 * @author zfh
 * @email hst1406959716@163.com
 * @date 2022-01-04 10:00:36
 */
public class CompletableFutureDemo3 {
    public static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
            5,20,10,
            TimeUnit.SECONDS,new LinkedBlockingDeque<>(1000),
            Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main......start.....");

        /**
         * 线程串行化
         * 1.thenRunXXX: 不能获取到上一步执行的结果,无返回值
         * 2.thenAcceptXXX: 能获取到上一步执行的结果,无返回值
         * 3.thenApplyXXX: 能获取到上一步执行的结果,有返回值
         */
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果：" + i);
            return i;
        }, threadPoolExecutor).thenApplyAsync(res -> {
            System.out.println("任务2启动..............." + res);
            return "java小生不才" + res;
        }, threadPoolExecutor);
        System.out.println("main......end......." + future.get());
    }
}

在这里插入图片描述

3.两任务组合 - 都要完成

两个任务必须都完成，触发该任务

  • thenCombine：组合两个 future，获取两个 future 的返回结果，并返回当前任务的返回值
  • thenAcceptBoth：组合两个 future，获取两个 future 任务的返回结果，然后处理任务，没有返回值
  • runAfterBoth：组合两个 future，不需要获取 future 的结果，只需两个 future 处理完任务后，处理该任务

3.1.runAfterBothAsync

组合两个future，不能感知前2个future的结果，只需两个future处理完任务后，执行处理第3个任务

package com.atguigu.gulimall.search.thread;

import java.util.concurrent.*;

/**
 * 异步编排CompletableFuture(两任务组合-2个任务都要完成才执行任务3)
 * @author zfh
 * @email hst1406959716@163.com
 * @date 2022-01-04 10:03:36
 */
public class CompletableFutureDemo4 {
    public static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
            5,20,10,
            TimeUnit.SECONDS,new LinkedBlockingDeque<>(1000),
            Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main......start.....");

        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务1线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("任务1运行结果：" + i);
            return i;
        }, threadPoolExecutor);

        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务2线程：" + Thread.currentThread().getId());
            System.out.println("任务2运行结果：");
            return "hello";
        }, threadPoolExecutor);

        //runAfterBothXXX:组合两个future，不能感知前2个future的结果，只需两个future处理完任务后，执行处理第3个任务
        future1.runAfterBothAsync(future2,() -> {
            System.out.println("任务3.........");
        }, threadPoolExecutor);

    }
}

在这里插入图片描述

3.2.thenAcceptBothAsync

组合两个 future，获取两个 future 任务的返回结果，然后处理任务，没有返回值

package com.atguigu.gulimall.search.thread;

import java.util.concurrent.*;

/**
 * 异步编排CompletableFuture(两任务组合-2个任务都要完成才执行任务3)
 * @author zfh
 * @email hst1406959716@163.com
 * @date 2022-01-04 10:03:36
 */
public class CompletableFutureDemo4 {
    public static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
            5,20,10,
            TimeUnit.SECONDS,new LinkedBlockingDeque<>(1000),
            Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main......start.....");

        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务1线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("任务1运行结果：" + i);
            return i;
        }, threadPoolExecutor);

        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务2线程：" + Thread.currentThread().getId());
            System.out.println("任务2运行结果：");
            return "hello";
        }, threadPoolExecutor);

        //1.runAfterBothXXX:组合两个future，不能感知前2个future的结果，只需两个future处理完任务后，执行处理第3个任务
//        future1.runAfterBothAsync(future2,() -> {
//            System.out.println("任务3.........");
//        }, threadPoolExecutor);


        //2.thenAcceptBothXXX:组合两个 future，获取两个 future 任务的返回结果，然后处理任务，没有返回值
        future1.thenAcceptBothAsync(future2,(f1res,f2res)->{
            System.out.println("任务3.........任务1结果: " + f1res + ",任务2结果: " + f2res);
        },threadPoolExecutor);
        System.out.println("main......end.......");
    }
}

在这里插入图片描述

3.3.thenCombineAsync

组合两个future，获取两个future的返回结果，并返回当前任务的返回值

package com.atguigu.gulimall.search.thread;

import java.util.concurrent.*;

/**
 * 异步编排CompletableFuture(两任务组合-2个任务都要完成才执行任务3)
 * @author zfh
 * @email hst1406959716@163.com
 * @date 2022-01-04 10:03:36
 */
public class CompletableFutureDemo4 {
    public static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
            5,20,10,
            TimeUnit.SECONDS,new LinkedBlockingDeque<>(1000),
            Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main......start.....");

        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务1线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("任务1运行结果：" + i);
            return i;
        }, threadPoolExecutor);

        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务2线程：" + Thread.currentThread().getId());
            System.out.println("任务2运行结果：");
            return "hello";
        }, threadPoolExecutor);

        //1.runAfterBothXXX:组合两个future，不能感知前2个future的结果，只需两个future处理完任务后，执行处理第3个任务
//        future1.runAfterBothAsync(future2,() -> {
//            System.out.println("任务3.........");
//        }, threadPoolExecutor);


        //2.thenAcceptBothXXX:组合两个 future，获取两个 future 任务的返回结果，然后处理任务，没有返回值
//        future1.thenAcceptBothAsync(future2,(f1res,f2res)->{
//            System.out.println("任务3.........任务1结果: " + f1res + ",任务2结果: " + f2res);
//        },threadPoolExecutor);


        //3.thenCombineXXX: 组合两个future，获取两个future的返回结果，并返回当前任务的返回值
        CompletableFuture<String> future3 = future1.thenCombineAsync(future2, (f1res, f2res) -> {
            System.out.println("任务3.........任务1结果: " + f1res + ",任务2结果: " + f2res);
            return "任务3可以有返回值";
        }, threadPoolExecutor);
        System.out.println("main......end......." + future3.get());
    }
}

在这里插入图片描述

4.两任务组合—一个完成

两任务组合------只要有一个完成就执行任务3

4.1.runAfterEitherAsync

package com.atguigu.gulimall.search.thread;

import java.util.concurrent.*;

/**
 * 异步编排CompletableFuture(两任务组合------只要有一个完成就执行任务3)
 * @author zfh
 * @email hst1406959716@163.com
 * @date 2022-01-04 10:06:36
 */
public class CompletableFutureDemo5 {
    public static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
            5,20,10,
            TimeUnit.SECONDS,new LinkedBlockingDeque<>(1000),
            Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main......start.....");

        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务1线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("任务1运行结果：" + i);
            return i;
        }, threadPoolExecutor);

        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务2线程：" + Thread.currentThread().getId());
            try {
                Thread.sleep(5000);
                System.out.println("任务2运行结果：");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "hello";
        }, threadPoolExecutor);

        //1.runAfterEitherXXX:组合两个future，不能感知前2个future的结果，只需1个future处理完任务后，执行处理第3个任务
        future1.runAfterEitherAsync(future2,()->{
            System.out.println("任务3............");
        },threadPoolExecutor);


        System.out.println("main......end......." );
    }
}

在这里插入图片描述

4.2.acceptEitherAsync

package com.atguigu.gulimall.search.thread;

import java.util.concurrent.*;

/**
 * 异步编排CompletableFuture(两任务组合------只要有一个完成就执行任务3)
 * @author zfh
 * @email hst1406959716@163.com
 * @date 2022-01-04 10:06:36
 */
public class CompletableFutureDemo5 {
    public static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
            5,20,10,
            TimeUnit.SECONDS,new LinkedBlockingDeque<>(1000),
            Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main......start.....");

        CompletableFuture<Object> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务1线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("任务1运行结果：" + i);
            return i;
        }, threadPoolExecutor);


        CompletableFuture<Object> future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务2线程：" + Thread.currentThread().getId());
            try {
                Thread.sleep(5000);
                System.out.println("任务2运行结果：");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "hello";
        }, threadPoolExecutor);

        //1.runAfterEitherXXX:组合两个future，不能感知前2个future的结果，只需1个future处理完任务后，执行处理第3个任务
//        future1.runAfterEitherAsync(future2,()->{
//            System.out.println("任务3............");
//        },threadPoolExecutor);

        //2.acceptEitherXXX:组合两个future,感知之前任务的结果,但没有返回值
        future1.acceptEitherAsync(future2,(res)->{
            System.out.println("任务3.........之前任务结果: " + res );
        },threadPoolExecutor);

        System.out.println("main......end......." );
    }
}

在这里插入图片描述

4.3.applyToEitherAsync

package com.atguigu.gulimall.search.thread;

import java.util.concurrent.*;

/**
 * 异步编排CompletableFuture(两任务组合------只要有一个完成就执行任务3)
 * @author zfh
 * @email hst1406959716@163.com
 * @date 2022-01-04 10:06:36
 */
public class CompletableFutureDemo5 {
    public static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
            5,20,10,
            TimeUnit.SECONDS,new LinkedBlockingDeque<>(1000),
            Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main......start.....");

        CompletableFuture<Object> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务1线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("任务1运行结果：" + i);
            return i;
        }, threadPoolExecutor);


        CompletableFuture<Object> future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务2线程：" + Thread.currentThread().getId());
            try {
                Thread.sleep(5000);
                System.out.println("任务2运行结果：");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "hello";
        }, threadPoolExecutor);

        //1.runAfterEitherXXX:组合两个future，不能感知前2个future的结果，只需1个future处理完任务后，执行处理第3个任务
//        future1.runAfterEitherAsync(future2,()->{
//            System.out.println("任务3............");
//        },threadPoolExecutor);

        //2.acceptEitherXXX:组合两个future,感知之前任务的结果,但没有返回值
//        future1.acceptEitherAsync(future2,(res)->{
//            System.out.println("任务3.........之前任务结果: " + res );
//        },threadPoolExecutor);

        //3.applyToEitherXXX: 感知之前任务的结果,有返回值
        CompletableFuture<String> future3 = future1.applyToEitherAsync(future2, (res) -> {
            System.out.println("任务3.........任务1结果: " + res);
            return "任务3可以有返回值";
        }, threadPoolExecutor);

        System.out.println("main......end......." + future3.get() );

    }
}

在这里插入图片描述

5.多任务组合

package com.atguigu.gulimall.search.thread;

import java.util.concurrent.*;

/**
 * 异步编排CompletableFuture(多任务组合)
 * @author zfh
 * @email hst1406959716@163.com
 * @date 2022-01-04 10:07:56
 */
public class CompletableFutureDemo6 {
    public static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
            5,20,10,
            TimeUnit.SECONDS,new LinkedBlockingDeque<>(1000),
            Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main......start.....");

        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("查询商品图片.....");
            return "iphone13.jpg";
        }, threadPoolExecutor);

        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("查询商品属性.....");
            return "远峰蓝 256G";
        }, threadPoolExecutor);

        CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000);
                System.out.println("查询商品介绍.....");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Iphone13 PRO MAX";
        }, threadPoolExecutor);

          //allOf 等待所有任务完成
//        CompletableFuture<Void> future = CompletableFuture.allOf(future1, future2, future3);
        //anyOf 只要有一个任务完成
        CompletableFuture<Object> future = CompletableFuture.anyOf(future1, future2, future3);

        System.out.println("main......end......."  );
    }
}

在这里插入图片描述
在这里插入图片描述

Java小生不才
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CompletableFuture 异步处理
07-16
总结，CompletableFuture是Java中处理异步编程的强大工具，它通过提供丰富的API和灵活的任务编排方式，简化了异步编程的复杂性，提升了代码的可读性和可维护性。开发者可以根据具体需求选择合适的方法，创建和组合...
异步编排.java
06-30
异步编排.java
CompletableFuture的runAfterBothAsync
Zhang Phil
07-02 2006
CompletableFuture的runAfterBothAsyncrunAfterBothAsync：假设有两个线程A和B，这两个线程都是异步执行的，但是不确定A和B何时执行完毕，但是需要在A和B都执行完毕后运行线程C。package zhangphil.test; import android.os.Bundle; import android.support.annotation.Nul...
CompletableFuture详解~runAfterBoth
小强快跑~~
02-28 661
这个例子演示了依赖的CompletableFuture如果等待两个阶段完成后执行了一个Runnable。注意下面所有的阶段都是同步执行的，第一个阶段执行大写转换，第二个阶段执行小写转换 static void runAfterBothExample() { String original = "Message"; StringBuilder result = new StringBuilder(); CompletableFuture.completedFuture(origin
使用CompletableFuture进行异步编排
最新发布
shenxiaomo1688的博客
06-16 28
p198 handler最终处理。p201 两任务组合 一个完成。只需要任意一个任务执行结束。p200 两任务组合。等待多个任务全部结束。
Java中CompletableFuture多线程任务异步编排
曹举的个人博客
05-28 3497
今天来简单看一下CompletableFuture多线程任务异步编排 为什么需要CompletableFuture？ 当多线程任务出现了相互依赖，需要按照一定的顺序执行的时候就需要用到CompletableFuture多线程任务异步编排 按照我的理解：CompletableFuture可以分为一下几种情况 1、单任务 2、两任务的编排 3、三任务的编排 4、多任务的编排 ...
CompletableFuture异步编排（两任务组合——两个任务必须都完成才触发另一个任务 ）
小志的博客
08-23 1240
CompletableFuture异步编排（两任务组合——两个任务必须都完成才触发另一个任务 ）
CompletableFuture 常用方法
jcj_lcc的博客
02-02 145
CompletableFuture 常用方法
Java并发 CompletableFuture异步编程的实现
08-25
Java并发 CompletableFuture异步编程的实现 在 Java 中，CompletableFuture 是一种异步编程的实现方式，它可以帮助开发者轻松地实现异步操作。CompletableFuture 的核心优势在于它可以将串行操作变成并行操作，从而...
在Spring Boot2中使用CompletableFuture的方法教程
08-26
在Spring Boot 2中，`CompletableFuture`是一个强大的工具，用于构建异步、非阻塞的应用程序。结合`@Async`注解，可以轻松地实现并发处理，提高应用的性能和响应速度。本文将深入探讨如何在Spring Boot 2中有效地...
【Java分享客栈】一文搞定京东零售开源的AsyncTool，彻底解决异步编排问题。.doc
07-12
在上一篇讲CompletableFuture的文章中，我们了解了CompletableFuture提供的串行、并行等常用异步编排的方案。但是，在细节上还是有许多不足，比如回调方面，编排复杂顺序方面。因此，我们需要一种更加强大且灵活的...
Java8的CompletableFuture之二
06-01 2911
前面章节介绍了 CompletableFuture的一些基础功能，现在介绍复杂的一些高级功能。上一节介绍了onCombine是用来并行组合两个独立的Future，这需要建立一个新的CompletableFuture来组合利用两个结果，如果我们现在只是要求两个future计算完成后通知一下，怎么办？可以使用thenAcceptBoth()/runAfterBoth()。 thenAcceptB
Java线程池-异步任务编排
鸣鼓ming的博客
08-15 1451
FutureTask可以拿到返回结果，可以处理异常 futureTask.get()阻塞等待整个线程执行完成，获取返回结果 线程池工作流程图 corePoolSize（必需）：核心线程数。默认情况下，核心线程会一直存活，但是当将 allowCoreThreadTimeout 设置为 true 时，核心线程也会超时回收。maximumPoolSize（必需）：线程池所能容纳的最大线程数。当活跃线程数达到该数值后，后续的新任务将会阻塞。keepAliveTime（必需）：线程闲置超时时长。如果超过该时长，非核
CompletableFuture详细介绍及方法使用示例(一)
Ascend1977的博客
05-25 8583
CompletableFuture是Java 8中引入的一种实现异步编程模型的方式，它是Future的扩展，提供了更强大、更灵活的功能。CompletableFuture可以表示两个异步任务之间的顺序关系或并行关系，同时提供了一些方便的工具方法来组合这些关系。
一文搞懂CompletableFuture的使用
weixin_45987961的博客
01-24 4285
前言 创建线程的方式只有两种：继承Thread或者实现Runnable接口。 但是这两种方法都存在一个缺陷，没有返回值 Java 1.5 以后，可以通过向线程池提交一个Callable来获取一个包含返回值的Future对象 Future接口的局限性 当Future的线程进行了一个非常耗时的操作，那我们的主线程也就阻塞了。 当我们在简单业务上，可以使用Future的另一个重载方法get(long,TimeUnit)来设置超时时间，避免我们的主线程被无穷尽地阻塞。 单纯使用Future接口或者Fut
CompletableFuture详解-初遇者-很细
码灵的博客
05-26 5654
CompletableFuture是jdk8的新特性。CompletableFuture实现了CompletionStage接口和Future接口，前者是对后者的一个扩展，增加了异步会点、流式处理、多个Future组合处理的能力，使Java在处理多任务的协同工作时更加顺畅便利。代码涉及到lambda表达式用法，不熟悉的可先看下。
Future & CompleteFuture 剖析实战【掌握了future，就掌握了未来】
沮丧的南瓜
12-07 4324
文章目录一、Callable&Future&FutureTask介绍1.1 Callable和Runnable的区别1.2 Future 的主要功能1.3 利用 FutureTask 创建 Future1.4 如何使用1.5 使用案例：促销活动中商品信息查询1.6 Future 注意事项1.7 Future的局限性二、CompletionService介绍2.1 CompletionService原理2.2 使用案例询价应用：向不同电商平台询价，并保存价格2.3 实现类似 Dubbo 的 F
【无标题】CompletableFuture操作
m0_49076525的博客
06-09 132
package com.canal.util; import com.google.common.collect.Lists; import lombok.Data; import lombok.extern.slf4j.Slf4j; import java.util.ArrayList; import java.util.List; import java.util.Random; import java.util.concurrent.*; import java.util.concurrent.a
CompletableFuture常用方法
weixin_45486746的博客
05-25 7525
1.创建异步任务 CompletableFuture.runAsync():创建一个没有返回值的异步任务。 CompletableFuture<Void> runComplete = CompletableFuture.runAsync(()-> System.out.println("没有返回值的异步任务")); CompletableFuture.supplyAsync():常见一个有返回值的异步任务。 CompletableFuture<String> support
completablefuture异步编排
03-16
CompletableFuture异步编排是一种Java编程语言中的异步编程模型，它可以让开发者更加方便地进行异步编程。CompletableFuture可以用来表示一个异步操作的结果，同时还可以将多个异步操作组合起来，形成一个异步操作链...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值