CompletableFuture 使用教程

最新推荐文章于 2024-09-18 17:01:25 发布
最新推荐文章于 2024-09-18 17:01:25 发布
阅读量1k 收藏 3
点赞数
分类专栏： 并发编程 文章标签： java jvm servlet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40977118/article/details/128101532
版权

目录

CompletableFuture实现了CompletionStage接口和Future接口，CompletionStage是对Future的一个扩展，增加了异步回调、流式处理、多个Future组合处理的能力，使Java在处理多任务的协同工作时更加顺畅便利。

Future没有提供通知机制，Future是否执行完任务需要通过轮询isDone这个方法查询执行结果或者调用get()方法阻塞任务执行，CompletionStage解决了该问题，前一个任务执行成功后可以自动触发下一个任务的执行，中间无需等待。

1. 创建异步任务

supplyAsync方法

//使用默认内置线程池ForkJoinPool.commonPool()，根据supplier构建执行任务
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)
//自定义线程，根据supplier构建执行任务
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor)

runAsync方法

//使用默认内置线程池ForkJoinPool.commonPool()，根据runnable构建执行任务
public static CompletableFuture<Void> runAsync(Runnable runnable) 
//自定义线程，根据runnable构建执行任务
public static CompletableFuture<Void> runAsync(Runnable runnable,  Executor executor)
  • supplyAsync执行CompletableFuture任务，支持返回值
  • runAsync执行CompletableFuture任务，没有返回值。
package com.example.mavendemo;

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

import lombok.extern.slf4j.Slf4j;

public class Test {

    static ExecutorService fishExecutor = Executors.newCachedThreadPool((r) -> new Thread(r, "fish"));
    static UserService userService = new UserService();

    public static void main(String[] args) {
        CompletableFuture<Void> runFuture =
            CompletableFuture.runAsync(() -> userService.compute("runAsync"), fishExecutor);
        CompletableFuture<String> supplyFuture =
            CompletableFuture.supplyAsync(() -> userService.compute("supplyAsync"), fishExecutor);
        System.out.println(runFuture.join());
        System.out.println(supplyFuture.join());
        fishExecutor.shutdown();
    }

    @Slf4j
    static class UserService {

        public String compute(String message) {
            log.info(message);
            return message;
        }

    }
}

join与get的区别

  • 相同点
    1.join()和get()方法都是用来获取CompletableFuture异步之后的返回值

  • 不同点
    1.join()方法抛出的是RuntimeException异常，不需要特殊处理
    2.get()方法抛出的是需要手动处理的异常，例如ExecutionException, InterruptedException，需要抛出或者try-catch

  • 结果打印

16:45:22.054 [fish] INFO com.example.mavendemo.Test$UserService - runAsync
16:45:22.054 [fish] INFO com.example.mavendemo.Test$UserService - supplyAsync
null
supplyAsync

2. 任务异步回调

1. thenRun/thenRunAsync

public CompletableFuture<Void> thenRun(Runnable action);
public CompletableFuture<Void> thenRunAsync(Runnable action);
  • thenRun/thenRunAsync作用是做完第一个任务后，再做第二个任务(Runnable action)。前一个任务执行结束后，执行回调方法(Runnable action)；但是两个任务之间没有参数传递，第二个任务也没有返回值
  • thenRun 和 thenRunAsync 的区别：

thenRun执行第二个任务的线程池和第一个任务是同一个，或者thenRunAsync传入的线程池
thenRunAsync执行第二个任务使用的是ForkJoin线程池，或者你传入的线程池

    public CompletableFuture<Void> thenRun(Runnable action) {
        return uniRunStage(null, action);
    }

    public CompletableFuture<Void> thenRunAsync(Runnable action) {
        return uniRunStage(asyncPool, action);
    }

    public CompletableFuture<Void> thenRunAsync(Runnable action, Executor executor) {
        return uniRunStage(screenExecutor(executor), action);
    }    


package com.example.mavendemo;

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

import lombok.extern.slf4j.Slf4j;

public class Test2 {

    static ExecutorService fishExecutor = Executors.newCachedThreadPool((r) -> new Thread(r, "fish"));

    public static void main(String[] args) {
        CompletableFuture<String> supplyFuture =
            CompletableFuture.supplyAsync(() -> userService.compute("第一个任务"), fishExecutor);
        CompletableFuture<Void> voidCompletableFuture1 = supplyFuture.thenRun(() -> userService.noResult("第二个任务"));
        CompletableFuture<Void> voidCompletableFuture2 = supplyFuture.thenRunAsync(() -> userService.noResult("第三个任务"));
        System.out.println(voidCompletableFuture1.join());
        System.out.println(voidCompletableFuture2.join());
        fishExecutor.shutdown();
    }

    @Slf4j
    static class UserService {

        public String compute(String message) {
            log.info(message);
            return message;
        }

        public void noResult(String message) {
            log.info(message);
        }

    }
}
  • 打印，第二个任务和第一个任务使用fish线程
16:45:48.526 [fish] INFO com.example.mavendemo.Test2$UserService - 第一个任务
16:45:48.529 [fish] INFO com.example.mavendemo.Test2$UserService - 第二个任务
null
16:45:48.530 [ForkJoinPool.commonPool-worker-9] INFO com.example.mavendemo.Test2$UserService - 第三个任务
null
  • 加入第四任务，在看任务使用的线程
package com.example.mavendemo;

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

import lombok.extern.slf4j.Slf4j;

public class Test2 {

    static ExecutorService fishExecutor = Executors.newCachedThreadPool((r) -> new Thread(r, "fish"));
    static ExecutorService catExecutor = Executors.newCachedThreadPool((r) -> new Thread(r, "cat"));
    static UserService userService = new UserService();

    public static void main(String[] args) {
        CompletableFuture<String> supplyFuture =
            CompletableFuture.supplyAsync(() -> userService.compute("第一个任务"), fishExecutor);
        CompletableFuture<Void> voidCompletableFuture1 = supplyFuture.thenRun(() -> userService.noResult("第二个任务"));
        CompletableFuture<Void> voidCompletableFuture2 = supplyFuture.thenRunAsync(() -> userService.noResult("第三个任务"));
        CompletableFuture<Void> voidCompletableFuture3 =
            supplyFuture.thenRunAsync(() -> userService.noResult("第四个任务"), catExecutor);
        System.out.println(voidCompletableFuture1.join());
        System.out.println(voidCompletableFuture2.join());
        System.out.println(voidCompletableFuture3.join());
        fishExecutor.shutdown();
        catExecutor.shutdown();
    }

    @Slf4j
    static class UserService {

        public String compute(String message) {
            log.info(message);
            return message;
        }

        public void noResult(String message) {
            log.info(message);
        }

    }
}
  • 打印，第二个任务和第四个任务使用cat线程，第三个任务使用ForkJoinPool线程
16:47:34.132 [fish] INFO com.example.mavendemo.Test2$UserService - 第一个任务
16:47:34.134 [cat] INFO com.example.mavendemo.Test2$UserService - 第四个任务
16:47:34.134 [cat] INFO com.example.mavendemo.Test2$UserService - 第二个任务
null
16:47:34.135 [ForkJoinPool.commonPool-worker-9] INFO com.example.mavendemo.Test2$UserService - 第三个任务
null
null

2. thenAccept/thenAcceptAsync

  • 第一个任务执行结束后，执行第二个回调方法任务，会将第一个任务的执行结果作为入参，传递到回调方法中，但回调方法没有返回值
package com.example.mavendemo;

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

import lombok.extern.slf4j.Slf4j;

public class Test3 {

    static ExecutorService fishExecutor = Executors.newCachedThreadPool((r) -> new Thread(r, "fish"));
    static UserService userService = new UserService();

    public static void main(String[] args) {
        CompletableFuture<String> supplyFuture =
            CompletableFuture.supplyAsync(() -> userService.compute("这是第一个任务"), fishExecutor);
        CompletableFuture<Void> voidCompletableFuture1 =
            supplyFuture.thenAccept((a) -> userService.noResult("传入了前一个任务的结果：" + a));
        CompletableFuture<Void> voidCompletableFuture2 =
            supplyFuture.thenAcceptAsync((a) -> userService.noResult("传入了前一个任务的结果：" + a));
        System.out.println(voidCompletableFuture1.join());
        System.out.println(voidCompletableFuture2.join());
        fishExecutor.shutdown();
    }

    @Slf4j
    static class UserService {

        public String compute(String message) {
            log.info(message);
            return message;
        }

        public void noResult(String message) {
            log.info(message);
        }

    }
}
  • 打印
17:01:09.637 [fish] INFO com.example.mavendemo.Test3$UserService - 这是第一个任务
17:01:09.639 [fish] INFO com.example.mavendemo.Test3$UserService - 传入了前一个任务的结果：这是第一个任务
17:01:09.639 [ForkJoinPool.commonPool-worker-9] INFO com.example.mavendemo.Test3$UserService - 传入了前一个任务的结果：这是第一个任务
null
null

3. thenApply/thenApplyAsync

  • 第一个任务执行完成后，执行第二个任务的回调方法，将第一个任务的执行结果作为入参，传递到回调方法中，而且回调方法有返回值。
package com.example.mavendemo;

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

import lombok.extern.slf4j.Slf4j;

public class Test4 {

    static ExecutorService fishExecutor = Executors.newCachedThreadPool((r) -> new Thread(r, "fish"));
    static UserService userService = new UserService();

    public static void main(String[] args) {
        CompletableFuture<String> supplyFuture =
            CompletableFuture.supplyAsync(() -> userService.compute("这是第一个任务"), fishExecutor);
        CompletableFuture<String> voidCompletableFuture1 =
            supplyFuture.thenApply((a) -> userService.compute("传入了前一个任务的结果：" + a));
        CompletableFuture<String> voidCompletableFuture2 =
            supplyFuture.thenApplyAsync((a) -> userService.compute("传入了前一个任务的结果：" + a));
        System.out.println(voidCompletableFuture1.join());
        System.out.println(voidCompletableFuture2.join());
        fishExecutor.shutdown();
    }

    @Slf4j
    static class UserService {

        public String compute(String message) {
            log.info(message);
            return message;
        }

        public void noResult(String message) {
            log.info(message);
        }

    }
}
  • 打印
17:06:08.946 [fish] INFO com.example.mavendemo.Test4$UserService - 这是第一个任务
17:06:08.948 [fish] INFO com.example.mavendemo.Test4$UserService - 传入了前一个任务的结果：这是第一个任务
传入了前一个任务的结果：这是第一个任务
17:06:08.948 [ForkJoinPool.commonPool-worker-9] INFO com.example.mavendemo.Test4$UserService - 传入了前一个任务的结果：这是第一个任务
传入了前一个任务的结果：这是第一个任务

4. exceptionally

  • 任务执行异常时，执行回调方法；并且将抛出的异常作为参数，传到回调方法
package com.example.mavendemo;

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

import lombok.extern.slf4j.Slf4j;

public class Test5 {

    static ExecutorService fishExecutor = Executors.newCachedThreadPool((r) -> new Thread(r, "fish"));
    static UserService userService = new UserService();

    public static void main(String[] args) {
        CompletableFuture<String> supplyFuture =
            CompletableFuture.supplyAsync(() -> userService.exceptionMethod("这是第一个任务"), fishExecutor);
        CompletableFuture<String> exceptionally = supplyFuture.exceptionally(o -> userService.catchException(o));
        System.out.println(exceptionally.join());
        fishExecutor.shutdown();
    }

    @Slf4j
    static class UserService {

        public String exceptionMethod(String message) {
            log.info(message);
            throw new RuntimeException(message);
        }

        public String catchException(Object o) {
            RuntimeException e = (RuntimeException)o;
            log.error("{}", e);
            return e.getMessage();
        }

    }
}
  • 打印
17:37:53.901 [fish] INFO com.example.mavendemo.Test5$UserService - 这是第一个任务
17:37:53.907 [fish] ERROR com.example.mavendemo.Test5$UserService - {}
java.util.concurrent.CompletionException: java.lang.RuntimeException: 这是第一个任务
	at java.util.concurrent.CompletableFuture.encodeThrowable(CompletableFuture.java:273)
	at java.util.concurrent.CompletableFuture.completeThrowable(CompletableFuture.java:280)
	at java.util.concurrent.CompletableFuture$AsyncSupply.run(CompletableFuture.java:1592)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
	at java.lang.Thread.run(Thread.java:748)
Caused by: java.lang.RuntimeException: 这是第一个任务
	at com.example.mavendemo.Test5$UserService.exceptionMethod(Test5.java:27)
	at com.example.mavendemo.Test5.lambda$main$1(Test5.java:16)
	at java.util.concurrent.CompletableFuture$AsyncSupply.run(CompletableFuture.java:1590)
	... 3 common frames omitted
java.lang.RuntimeException: 这是第一个任务

5. whenComplete/whenCompleteAsync

  • 第一个任务执行结束后，执行第二个回调方法任务，把上一级任务执行的结果和异常信息作为入参传入回调方法；并且whenComplete方法返回的CompletableFuture的result是上个任务的结果。
package com.example.mavendemo;

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

import lombok.extern.slf4j.Slf4j;

public class Test6 {

    static ExecutorService fishExecutor = Executors.newCachedThreadPool((r) -> new Thread(r, "fish"));
    static UserService userService = new UserService();

    public static void main(String[] args) {
        CompletableFuture<String> supplyFuture =
            CompletableFuture.supplyAsync(() -> userService.compute("这是第一个任务"), fishExecutor);
        CompletableFuture<String> voidCompletableFuture1 =
            supplyFuture.whenComplete((a,throwable) -> userService.compute("传入了前一个任务的结果：" + a));
        CompletableFuture<String> voidCompletableFuture2 =
            supplyFuture.whenCompleteAsync((a,throwable) -> userService.compute("传入了前一个任务的结果：" + a));
        System.out.println(voidCompletableFuture1.join());
        System.out.println(voidCompletableFuture2.join());
        fishExecutor.shutdown();
    }

    @Slf4j
    static class UserService {

        public String compute(String message) {
            log.info(message);
            return message;
        }

        public void noResult(String message) {
            log.info(message);
        }

    }
}
  • 打印
17:49:36.135 [fish] INFO com.example.mavendemo.Test6$UserService - 这是第一个任务
17:49:36.137 [fish] INFO com.example.mavendemo.Test6$UserService - 传入了前一个任务的结果：这是第一个任务
这是第一个任务
17:49:36.137 [ForkJoinPool.commonPool-worker-9] INFO com.example.mavendemo.Test6$UserService - 传入了前一个任务的结果：这是第一个任务
这是第一个任务

6. handle/handleAsync

  • 第一个任务执行结束后，执行第二个回调方法任务，把上一级任务执行的结果和异常信息作为入参传入回调方法；并且whenComplete方法返回的CompletableFuture的result是回调方法的结果。
package com.example.mavendemo;

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

import lombok.extern.slf4j.Slf4j;

public class Test7 {

    static ExecutorService fishExecutor = Executors.newCachedThreadPool((r) -> new Thread(r, "fish"));
    static UserService userService = new UserService();

    public static void main(String[] args) {
        CompletableFuture<String> supplyFuture =
            CompletableFuture.supplyAsync(() -> userService.compute("这是第一个任务"), fishExecutor);
        CompletableFuture<String> voidCompletableFuture1 =
            supplyFuture.handle((a,throwable) -> userService.compute("传入了前一个任务的结果：" + a));
        CompletableFuture<String> voidCompletableFuture2 =
            supplyFuture.handleAsync((a,throwable) -> userService.compute("传入了前一个任务的结果：" + a));
        System.out.println(voidCompletableFuture1.join());
        System.out.println(voidCompletableFuture2.join());
        fishExecutor.shutdown();
    }

    @Slf4j
    static class UserService {

        public String compute(String message) {
            log.info(message);
            return message;
        }

        public void noResult(String message) {
            log.info(message);
        }

    }
}
  • 打印
17:52:20.197 [fish] INFO com.example.mavendemo.Test7$UserService - 这是第一个任务
17:52:20.199 [fish] INFO com.example.mavendemo.Test7$UserService - 传入了前一个任务的结果：这是第一个任务
传入了前一个任务的结果：这是第一个任务
17:52:20.199 [ForkJoinPool.commonPool-worker-9] INFO com.example.mavendemo.Test7$UserService - 传入了前一个任务的结果：这是第一个任务
传入了前一个任务的结果：这是第一个任务

3. 多任务组合

1. AND

  • thenCombine / thenAcceptBoth / runAfterBoth都表示将两个CompletableFuture组合起来，只有这两个都正常执行结束，才会执行回调任务。
  • 区别在于：
    thenCombine/thenCombineAsync: 会将两个任务的执行结果作为入参，传到指定方法中，且有返回值
    thenAcceptBoth/thenAcceptBothAsync: 会将两个任务的执行结果作为入参，传到指定方法中，且无返回值
    runAfterBoth/runAfterBothAsync: 不会把执行结果当做入参，且没有返回值。
package com.example.mavendemo;

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

import lombok.extern.slf4j.Slf4j;

public class Test8 {

    static ExecutorService fishExecutor = Executors.newCachedThreadPool((r) -> new Thread(r, "fish"));
    static UserService userService = new UserService();

    public static void main(String[] args) {
        CompletableFuture<String> first =
            CompletableFuture.supplyAsync(() -> userService.compute("这是第一个任务"), fishExecutor);
        CompletableFuture<String> second =
            CompletableFuture.supplyAsync(() -> userService.compute("这是第二个任务"), fishExecutor);
        CompletableFuture<String> thenCombine = first.thenCombine(second, (s, s2) -> userService.combine(s, s2));
        System.out.println(thenCombine.join());
        fishExecutor.shutdown();
    }

    @Slf4j
    static class UserService {

        public String compute(String message) {
            log.info(message);
            return message;
        }

        public String combine(String first, String second) {
            log.info("这是combine方法");
            return first + second;
        }

    }
}
  • 打印
09:49:38.621 [fish] INFO com.example.mavendemo.Test8$UserService - 这是第二个任务
09:49:38.621 [fish] INFO com.example.mavendemo.Test8$UserService - 这是第一个任务
09:49:38.624 [fish] INFO com.example.mavendemo.Test8$UserService - 这是combine方法
这是第一个任务这是第二个任务

2. OR

  • applyToEither / acceptEither / runAfterEither 都表示：将两个CompletableFuture组合起来，只要其中一个执行结束，就会执行回调任务。
  • 区别在于：
    applyToEither/applyToEitherAsync: 会将已经执行完成的任务的结果作为入参，传到指定方法中，且有返回值
    acceptEither/acceptEitherAsync: 会将已经执行完成的任务的结果作为入参，传到指定方法中，且无返回值
    runAfterEither/runAfterEitherAsync: 不会把执行结果当做入参，且没有返回值。
package com.example.mavendemo;

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

import lombok.extern.slf4j.Slf4j;

public class Test9 {

    static ExecutorService fishExecutor = Executors.newCachedThreadPool((r) -> new Thread(r, "fish"));
    static UserService userService = new UserService();

    public static void main(String[] args) {
        CompletableFuture<String> first =
            CompletableFuture.supplyAsync(() -> userService.compute("这是第一个任务"), fishExecutor);
        CompletableFuture<String> second =
            CompletableFuture.supplyAsync(() -> userService.compute("这是第二个任务"), fishExecutor);
        CompletableFuture<String> applyToEither = first.applyToEither(second, s -> userService.either(s));
        System.out.println(applyToEither.join());
        fishExecutor.shutdown();
    }

    @Slf4j
    static class UserService {

        public String compute(String message) {
            log.info(message);
            return message;
        }

        public String either(String result) {
            log.info("这是either方法");
            return result;
        }

    }
}
  • 打印
10:02:51.523 [fish] INFO com.example.mavendemo.Test9$UserService - 这是第一个任务
10:02:51.523 [fish] INFO com.example.mavendemo.Test9$UserService - 这是第二个任务
10:02:51.526 [fish] INFO com.example.mavendemo.Test9$UserService - 这是either方法
这是第一个任务
  • 也可能打印
10:03:50.381 [fish] INFO com.example.mavendemo.Test9$UserService - 这是第二个任务
10:03:50.381 [fish] INFO com.example.mavendemo.Test9$UserService - 这是第一个任务
10:03:50.383 [fish] INFO com.example.mavendemo.Test9$UserService - 这是either方法
这是第二个任务

3. AllOf

  • 所有任务都执行完成后，才执行 allOf 返回的CompletableFuture。如果任意一个任务异常，allOf的CompletableFuture执行get或join方法，会抛出异常；如果都是正常执行，则返回null。
package com.example.mavendemo;

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

import lombok.extern.slf4j.Slf4j;

public class Test10 {

    static ExecutorService fishExecutor = Executors.newCachedThreadPool((r) -> new Thread(r, "fish"));
    static UserService userService = new UserService();

    public static void main(String[] args) {
        CompletableFuture<String> first =
            CompletableFuture.supplyAsync(() -> userService.compute("这是第一个任务"), fishExecutor);
        CompletableFuture<String> second =
            CompletableFuture.supplyAsync(() -> userService.error("这是第二个任务"), fishExecutor);

        CompletableFuture<Void> allOfFuture =
            CompletableFuture.allOf(first, second).whenComplete((unused, throwable) -> {
                System.out.println(unused);
                System.out.println(throwable.getMessage());
                System.out.println("finish");
            });
        System.out.println(allOfFuture.join());
        fishExecutor.shutdown();
    }

    @Slf4j
    static class UserService {

        public String compute(String message) {
            log.info(message);
            return message;
        }

        public String error(String message) {
            log.info(message);
            throw new RuntimeException("出错了");
        }
    }
}
  • 打印
10:41:43.120 [fish] INFO com.example.mavendemo.Test10$UserService - 这是第二个任务
10:41:43.120 [fish] INFO com.example.mavendemo.Test10$UserService - 这是第一个任务
null
java.lang.RuntimeException: 出错了
finish
Exception in thread "main" java.util.concurrent.CompletionException: java.lang.RuntimeException: 出错了
	at java.util.concurrent.CompletableFuture.encodeThrowable(CompletableFuture.java:273)
	at java.util.concurrent.CompletableFuture.completeThrowable(CompletableFuture.java:280)
	at java.util.concurrent.CompletableFuture$AsyncSupply.run(CompletableFuture.java:1592)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
	at java.lang.Thread.run(Thread.java:748)
Caused by: java.lang.RuntimeException: 出错了
	at com.example.mavendemo.Test10$UserService.computeError(Test10.java:40)
	at com.example.mavendemo.Test10.lambda$main$2(Test10.java:18)
	at java.util.concurrent.CompletableFuture$AsyncSupply.run(CompletableFuture.java:1590)
	... 3 more

4. AnyOf

  • 任意一个任务执行完，就执行anyOf返回的CompletableFuture。如果执行get或join方法，返回执行完任务的结果。
package com.example.mavendemo;

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

import lombok.extern.slf4j.Slf4j;

public class Test11 {

    static ExecutorService fishExecutor = Executors.newCachedThreadPool((r) -> new Thread(r, "fish"));
    static UserService userService = new UserService();

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<String> first =
            CompletableFuture.supplyAsync(() -> userService.compute("这是第一个任务"), fishExecutor);
        CompletableFuture<String> second =
            CompletableFuture.supplyAsync(() -> userService.compute("这是第二个任务"), fishExecutor);

        CompletableFuture<Object> anyOfFuture =
            CompletableFuture.anyOf(second, first).whenComplete((unused, throwable) -> {
                System.out.println(unused);
                System.out.println("finish");
            });
        System.out.println(anyOfFuture.join());
        fishExecutor.shutdown();
    }

    @Slf4j
    static class UserService {

        public String compute(String message) {
            log.info(message);
            return message;
        }

    }
}
  • 打印
13:15:46.529 [fish] INFO com.example.mavendemo.Test11$UserService - 这是第二个任务
13:15:46.529 [fish] INFO com.example.mavendemo.Test11$UserService - 这是第一个任务
这是第二个任务
finish
这是第二个任务

5. thenCompose/thenComposeAsync

  • 在一个任务执行完成后，将该任务的执行结果作为入参，传到指定的方法去执行，该方法会返回一个新的CompletableFuture实例。
package com.example.mavendemo;

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

import lombok.extern.slf4j.Slf4j;

public class Test12 {

    static ExecutorService fishExecutor = Executors.newCachedThreadPool((r) -> new Thread(r, "fish"));
    static UserService userService = new UserService();

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> first =
            CompletableFuture.supplyAsync(() -> userService.number("996"), fishExecutor);
        CompletableFuture<String> thenCompose = first.thenCompose(
            s -> CompletableFuture.supplyAsync(() -> userService.compute("这是第二个任务，接收到的入参是：" + s), fishExecutor));
        System.out.println(thenCompose.join());
        fishExecutor.shutdown();
    }

    @Slf4j
    static class UserService {

        public Integer number(String number) {
            log.info(number);
            return Integer.valueOf(number);
        }

        public String compute(String message) {
            log.info(message);
            return message;
        }

    }
}
  • 打印
13:57:16.096 [fish] INFO com.example.mavendemo.Test12$UserService - 996
13:57:16.098 [fish] INFO com.example.mavendemo.Test12$UserService - 这是第二个任务，接收到的入参是：996
这是第二个任务，接收到的入参是：996

注意点

  1. 如果任务执行发生异常，需要调用get()或join()获取返回值，才能获取异常信息；或者使用try…catch…或者使用exceptionally方法。

  2. CompletableFuture的get()方法是阻塞的，如果使用它来获取异步调用的返回值，最好添加超时时间，例如get(10, TimeUnit.SECONDS)

  3. 推荐使用自定义线程池，这样可以根据需要优化线程池配置

CompletableFutures使用
知识改变命运，ヾ(◍°∇°◍)ﾉﾞ【求关注】
03-27 203
这些查询接口包括单个对象查询、列表查询和分页查询等方法的 实现，因为是接口调用，查询的结果最终都是以Json结构的方式返回 文本数据的。为了更好地配合客户端高并发的非阻塞异步编程方式的 调用，这里同样使用了这种编程方式来实现高并发的调用。 ...
Java并发编程（二）—— CompletableFuture 超详细教程
gmHappy
12-18 799
Java并发编程—— CompletableFuture 超详细教程（源码分析）
CompletableFuture中的thenRun和thenRunAsync方法
liushuyul的博客
04-14 9068
需求： 我需要在做完第一件事情后返回结果A，再做第二件事情，第二件事情依赖结果A。 代码编程： @Resource(name = "globalThreadPool") private ThreadPoolExecutor threadPoolExecutor; CompletableFuture.supplyAsync(() -> { 做第一件事情; return A; },threadPoolExecutor).thenRun(()->{ 做第二件
史上最强异步编程~CompletableFuture精读
最新发布
zhouhengzhe的博客
09-18 2296
是一个强大的类，它同时实现了Future和两个关键接口，集成了异步计算结果的表示与异步计算流程编排的双重功能。Future接口：该接口定义了异步操作的结果，提供了检查任务是否完成、获取计算结果以及尝试取消任务的能力。它是对未来可能完成的计算结果的一个抽象表示。CompletionStage接口：作为异步计算流程的核心，代表了异步操作中的一个阶段，允许将多个异步操作串联起来，形成复杂的异步执行流程。通过它，开发者可以灵活地编排和组合多个异步任务，实现高效且易于管理的异步编程模型。方法描述是否有返回值。
CompletableFuture基本用法
weixin_34390105的博客
07-05 505
异步计算 所谓异步调用其实就是实现一个可无需等待被调用函数的返回值而让操作继续运行的方法。在 Java 语言中，简单的讲就是另启一个线程来完成调用中的部分计算，使调用继续运行或返回，而不需要等待计算结果。但调用者仍需要取线程的计算结果。 JDK5新增了Future接口，用于描述一个异步计算的结果。虽然 Future 以及相关使用方法提供了异步执行任务的能力，但是对于结果的获取却...
异步编程——CompletableFuture用法详解
kezhou的博客
02-19 1500
我们异步执行一个任务时，需要用线程池Executor如果不需要有返回值， 任务继承Thread类或实现Runnable接口；如果需要有返回值，任务实现Callable接口，调用Executor的submit方法执行任务，再使用获取任务结果。当我们得到包含结果的Future时，我们可以使用get方法等待线程完成并获取返回值，但问题是Future的get()方法会阻塞主线程。并且当多个线程存在依赖组合的时候，使用同步组件CountDownLatch是比较麻烦的。Java8新增的类提供了非常强大的。
CompletableFuture的使用
zhujian82637的博客
07-31 251
CompletableFuture多线程
在Spring Boot2中使用CompletableFuture的方法教程
08-26
本文将深入探讨如何在Spring Boot 2中有效地使用`CompletableFuture`。 首先，`@Async`注解允许我们标记一个方法为异步执行，这意味着该方法将在单独的线程中运行，而非阻塞当前的执行流程。为了启用这个特性，我们...
如何使用CompletableFuture
技术分享
11-22 1110
掌握CompletableFuture可以使我们更加容易写出优雅的并发编程代码
【项目实战】并发编程之CompletableFuture入门介绍
本本本添哥
07-17 284
CompletableFuture 是 Java 8 中引入的一个用于支持异步编程的类，它提供了一种方便的方式来执行异步任务，并可以通过链式调用的方式将多个任务串联起来。CompletableFuture 是一个实现了 Future 接口的类，它允许我们执行异步任务、等待任务完成并获取任务的结果。
ListenableFuture和CompletableFuture简单小结
热门推荐
走在前往架构师的路上
05-19 1万+
前言 最近花了点时间熟悉了下ListenableFuture和CompletableFuture的使用。二者都是原生JDK中老版Future-Get模式的改进。本文将结合demo程序来直观的学习一下这两大Future的使用特点。 老版Future模式的缺点 老版Future模式一个最大的问题是需要获取结果做后续处理操作的时候，还是需要阻塞等待。这样的话，和同步调用方式就没有多大区...
java关于Timer schedule执行定时任务
qq_45994827的博客
09-22 755
java关于Timer schedule执行定时任务 1、在应用开发中，经常需要一些周期性的操作，比如每5分钟执行某一操作等 1、在应用开发中，经常需要一些周期性的操作，比如每5分钟执行某一操作等。对于这样的操作最方便、高效的实现方式就是使用java.util.Timer工具类。 private java.util.Timer timer; timer = new Timer(true); timer.schedule( new java.util.TimerTask() { public void r..
java8CompletableFuture常用的异步操作
奔跑的菜鸡
01-13 997
IntStream //类似for循环 for(int i = 0; i < 3; i ++) IntStream intStream = IntStream.range(0, 3); supplyAsync运行一个异步任务并且返回结果 当任务不需要返回任何东西的时候可以使用 CompletableFuture.runAsync() CompletableFuture<String> future = CompletableFuture.supplyAsync(new Supplier
使用 CompletableFuture 实现所有任务都执行完之后在执行下一步操作
weixin_43440709的博客
03-31 7579
方法接收一个 CompletableFuture 数组，当所有 CompletableFuture 都完成时，它将返回一个新的 CompletableFuture，该 CompletableFuture 不包含任何结果，但表示所有任务都已完成。在 CompletableFuture 中实现所有任务都执行完之后再执行下一步操作，我们可以使用。方法在其上执行下一步操作。如果我们需要使用上一步的计算结果来执行下一步操作，我们应该使用。方法在所有任务完成后执行下一步操作。方法创建了三个异步任务，并使用。
CompletableFuture
Leon_Jinhai_Sun的博客
04-05 542
但是但我们使用get()方法获取异步执行的结果的时候,方法可能会阻塞 我们要通过isDone()判断异步执行结果是否已经完成 使用Future获得异步执行的结果有两个方法: 1. 阻塞的方法: get() 2 轮询: isDone() 都不是很好,我们期望在异步任务执行完毕的时候,我们能自动获得结果. 所以JDK提供了CompletableFuture接口: ...
CompletableFuture教程
weixin_42351206的博客
05-04 803
文章目录前言一、基础篇1、案例1_ CompletableFuture.supplyAsync()1.1、需求1.2、代码1.3、总结2、案例2_ CompletableFuture.thenCompose()2.1、需求2.2、代码2.3、总结3、案例3_ CompletableFuture.thenCombine()3.1、需求3.2、代码3.3、总结二、扩展篇1、案例1_ CompletableFuture.thenApplyAsync()1.1、需求1.2、代码1.3、总结2、案例2_ Comple
completablefuture thenrunasync 不运行_CompletableFuture之灭霸的故事
weixin_42187487的博客
01-14 1985
今天来说说CompletableFuture之灭霸的故事。CompletableFuture，它是Java1.8提供的用来支持异步编程的工具类。在Java1.5里就提供了Future接口。我们知道Future是强大的但是在多任务有聚合关系的情况下用起来就有点麻烦，而CompletableFuture就是用来解决任务之间的聚合关系的。对于灭霸来说他的得聚集六颗无限宝石,加上一个聚集宝石力...
玩转CompletableFuture异步编程
JavaAlliance
04-10 2345
CompletableFuture.supplyAsync Future是Java5新加的一个接口，它提供了一种异步并行计算的功能。如果主线程需要执行一个很耗时的计算任务，我们就可以通过future把这个任务放到异步线程中执行。主线程继续处理其他任务，处理完成后，再通过Future获取计算结果。 老爸有俩孩子：小红和小明。老爸想喝酒了，他让小红去买酒，小红出去了。然后老爸突然想吸烟了，于是老爸让小明去买烟。在面对对象的思想中，一般会把买东西，然后买回来这件事作为一个方法，如果按照顺序结构或者使用多线程同步
Java CompletableFuture 详解
chengqi5964的博客
06-14 249
Java CompletableFuture 详解 参考1：异步技巧之CompletableFuture 参考2：通过实例理解 JDK8 的 CompletableFuture 参考3：CompletableFuture 详解 参考4：多线程并发执行任务，取结果归集。终极总结：Future、F...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值