重拾Java基础知识：CompletableFuture

最新推荐文章于 2024-08-06 16:48:59 发布
最新推荐文章于 2024-08-06 16:48:59 发布
阅读量1.8k 收藏 3
点赞数
分类专栏： On Java 8 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39940674/article/details/124965555
版权

CompletableFuture

前言

CompletableFuture继承于java.util.concurrent.Future，它本身具备Future的所有特性，以及流式计算、函数式编程、完成通知、自定义异常处理、事件驱动编程模型等很多新的特性。可以用来实现多线程的串行关系，并行关系，聚合关系。使用这种并行方式，极大地提升了程序的表现。

CompletableFuture

创建CompletableFuture

一共有7中方式可以创建CompletableFuture，下面对他们一一进行介绍。

    public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier) {
        return asyncSupplyStage(asyncPool, supplier);
    }
    public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier,
                                                       Executor executor) {
        return asyncSupplyStage(screenExecutor(executor), supplier);
    }
    
    public static CompletableFuture<Void> runAsync(Runnable runnable) {
        return asyncRunStage(asyncPool, runnable);
    }
    public static CompletableFuture<Void> runAsync(Runnable runnable,
                                                   Executor executor) {
        return asyncRunStage(screenExecutor(executor), runnable);
    }
    
    public static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs) {
        return andTree(cfs, 0, cfs.length - 1);
    }
    public static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs) {
        return orTree(cfs, 0, cfs.length - 1);
    }
    public static <U> CompletableFuture<U> completedFuture(U value) {
        return new CompletableFuture<U>((value == null) ? NIL : value);
    }
  • supplyAsync()方法：表示创建带返回值的异步任务，两种方法，第一种只需传入一个Supplier实例；另一种可以指定自定义的线程池，然后将任务提交给该线程池执行，如果不指定，默认使用ForkJoinPool.commonPool()。

示例代码：

public class ExecutorTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("threadName: "+Thread.currentThread().getName());
            return "ok";
        }, Executors.newSingleThreadExecutor());
        String get = completableFuture.get();
        System.out.println(get);
        /** Output:
         * threadName: pool-1-thread-1
         * ok
         */
    }
}
  • runAsync()方法：传参是Runnable类型的，所以没有返回值。可自定义线程池，同supplyAsync()方法类似。

示例代码：

public class ExecutorTest {
    public static void main(String[] args) {
        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> {
            System.out.println("threadName: "+Thread.currentThread().getName());
        }, Executors.newSingleThreadExecutor());
        /** Output:
         * threadName: pool-1-thread-1
         */
    }
}
  • allOf()方法：多个任务完成，返回一个全新的已完成CompletableFuture，有一个任务执行异常，调用get()方法时会抛出异常，如果都是正常执行，则返回null。

示例代码：

public class ExecutorTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<String> c1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("task -1");
            return "task -1";
        });
        CompletableFuture<Void> c2 = CompletableFuture.runAsync(()->{
            System.out.println("task -2");
            //throw new RuntimeException(); get方法返回错误信息
        });
        CompletableFuture<String> c3 = CompletableFuture.supplyAsync(()->{
            System.out.println("task -3");
            return "task -3";
        });
        CompletableFuture<Void> completableFuture = CompletableFuture.allOf(c1,c2,c3);
        System.out.println(completableFuture.get());
        /** Output:
         * task -1
         * task -2
         * task -3
         * null
         */
    }
}
  • anyOf()方法：多个任务中任意一个任务完成，返回一个全新的已完成CompletableFuture，如果最快完成的任务执行异常，调用get()方法时会抛出异常，如果都是正常执行，则返回最快完成的任务结果。

示例代码：

public class ExecutorTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<String> c1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("task -1");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "task -1";
        });
        CompletableFuture<Void> c2 = CompletableFuture.runAsync(()->{
            System.out.println("task -2");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        CompletableFuture<String> c3 = CompletableFuture.supplyAsync(()->{
            System.out.println("task -3");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "task -3";
        });
        CompletableFuture<Object> completableFuture = CompletableFuture.anyOf(c1,c2,c3);
        System.out.println(completableFuture.get());
        /** Output:
         * task -1
         * task -2
         * task -3
         * task -3
         */
    }
}
  • completedFuture()方法：给定值，返回一个新的已完成的CompletableFuture。

示例代码：

public class ExecutorTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<String> completableFuture = CompletableFuture.completedFuture("hello");
        String s = completableFuture.get();
        System.out.println(s);
        /** Output:
         * hello
         */
    }
}

获取结果

获取结果有两种方式：get()方法和join()方法。

    public T get() throws InterruptedException, ExecutionException {
        Object r;
        return reportGet((r = result) == null ? waitingGet(true) : r);
    }
    public T get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException {
        Object r;
        long nanos = unit.toNanos(timeout);
        return reportGet((r = result) == null ? timedGet(nanos) : r);
    }
    public T getNow(T valueIfAbsent) {
        Object r;
        return ((r = result) == null) ? valueIfAbsent : reportJoin(r);
    }
    public T join() {
        Object r;
        return reportJoin((r = result) == null ? waitingGet(false) : r);
    }
  • get()方法：等待任务完成后，返回结果或抛出受检测异常。

示例代码：

public class ExecutorTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> "test");
        System.out.println(completableFuture.get());
        /** Output:
         * test
         */
        CompletableFuture<String> completableFuture1 = CompletableFuture.supplyAsync(() -> {
            throw new RuntimeException();
        });
        System.out.println(completableFuture1.get());
        /** Output:
         * Exception in thread "main" java.util.concurrent.ExecutionException: java.lang.RuntimeException
         * 	at java.util.concurrent.CompletableFuture.reportGet(CompletableFuture.java:357)
         * 	at java.util.concurrent.CompletableFuture.get(CompletableFuture.java:1895)
         * 	at com.study.test.ExecutorTest.main(ExecutorTest.java:11)
         * Caused by: java.lang.RuntimeException
         * ......
         */
    }
}
  • get(long timeout, TimeUnit unit)方法：指定时间内获取值，超出时长，抛异常。

示例代码：

public class ExecutorTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "test";
        });
        System.out.println(completableFuture.get(1,TimeUnit.SECONDS));
        /** Output:
         * Exception in thread "main" java.util.concurrent.TimeoutException
         * 	at java.util.concurrent.CompletableFuture.timedGet(CompletableFuture.java:1771)
         * 	at java.util.concurrent.CompletableFuture.get(CompletableFuture.java:1915)
         * 	at com.study.test.ExecutorTest.main(ExecutorTest.java:16)
         */
    }
}
  • getNow(T valueIfAbsent)方法：返回结果值等于null，返回指定valueIfAbsent，否则返回已完成任务的结果。。

示例代码：

public class ExecutorTest {
    public static void main(String[] args) {
        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> null);
        System.out.println(completableFuture.getNow("test"));
        /** Output:
         * test
         */
    }
}
  • join()方法：你以为它是线程里的合并是一样，其实不是。与get()方法一样。

示例代码：

public class ExecutorTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> "test");
        System.out.println(completableFuture.join());
        /** Output:
         * test
         */
        CompletableFuture<String> completableFuture1 = CompletableFuture.supplyAsync(() -> {
            throw new RuntimeException();
        });
        System.out.println(completableFuture1.join());
        /** Output:
         * Exception in thread "main" java.util.concurrent.ExecutionException: java.lang.RuntimeException
         * 	at java.util.concurrent.CompletableFuture.reportGet(CompletableFuture.java:357)
         * 	at java.util.concurrent.CompletableFuture.get(CompletableFuture.java:1895)
         * 	at com.study.test.ExecutorTest.main(ExecutorTest.java:11)
         * Caused by: java.lang.RuntimeException
         * ......
         */
    }
}

后续处理

或许你有时候需要在任务执行完成后，进行其它任务的处理，CompletableFuture提供了很多方法，方便你的操作。

单任务结果
  • thenApply()方法：有传参有返回值。上一个任务的执行结果当作参数传入且返回自定义结果。

示例代码：

public class ExecutorTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException{
        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务一的线程名："+Thread.currentThread().getName());
            return "任务一";
        }).thenApply(param->{
            System.out.println("thenApply的线程名："+Thread.currentThread().getName()+"，参数："+param);
            return "thenApply "+ param;
        });
        System.out.println(completableFuture.get());
        /** Output:
         * 任务一的线程名：ForkJoinPool.commonPool-worker-1
         * thenApply的线程名：main，参数：任务一
         * thenApply 任务一
         */
    }
}
  • thenCompose()方法：有传参有返回值。与thenApply()方法不同，上一个任务的执行结果当作参数传入且返回一个新的任务。

示例代码：

public class ExecutorTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException{
        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务一的线程名："+Thread.currentThread().getName());
            return "任务一";
        }).thenCompose((p1) -> {
            System.out.println("thenCombine的线程名：" + Thread.currentThread().getName()+"，参数："+p1);
            return CompletableFuture.supplyAsync(()->"thenCompose");
        });
        System.out.println(completableFuture.get());
        /** Output:
         * 任务一的线程名：ForkJoinPool.commonPool-worker-1
         * thenCombine的线程名：main，参数：任务一
         * thenCompose
         */
    }
}
  • thenApplyAsync()方法：Async后缀的函数表示需要连接的后置任务会被单独提交到线程池中，从而相对前置任务来说是异步运行的。除此之外，两者没有其他区别。在接下来的介绍中，不讲解Async后缀的方法。

示例代码：

public class ExecutorTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务一的线程名："+Thread.currentThread().getName());
            return "任务一";
        }).thenApplyAsync(param->{
            System.out.println("thenApply的线程名："+Thread.currentThread().getName()+"，参数："+param);
            return "thenApply "+ param;
        });
        System.out.println(completableFuture.get());
        /** Output:
         * 任务一的线程名：ForkJoinPool.commonPool-worker-1
         * thenApply的线程名：ForkJoinPool.commonPool-worker-1，参数：任务一
         * thenApply 任务一
         */
    }
}
  • thenAccept()方法：有传参无返回值。上一个任务的执行结果当作参数传入。

示例代码：

public class ExecutorTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        CompletableFuture<Void> completableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务一的线程名："+Thread.currentThread().getName());
            return "任务一";
        }).thenAccept(param->{
            System.out.println("thenApply的线程名："+Thread.currentThread().getName()+"，参数："+param);
        });
        System.out.println(completableFuture.get());
        /** Output:
         * 任务一的线程名：ForkJoinPool.commonPool-worker-1
         * thenApply的线程名：main，参数：任务一
         * null
         */
    }
}
  • thenRun()方法：无传参无返回值，上一个任务执行完在执行此任务。

示例代码：

public class ExecutorTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        CompletableFuture<Void> completableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务一的线程名："+Thread.currentThread().getName());
            return "任务一";
        }).thenRun(()->{
            System.out.println("thenApply的线程名："+Thread.currentThread().getName());
        });
        System.out.println(completableFuture.get());
        /** Output:
         * 任务一的线程名：ForkJoinPool.commonPool-worker-1
         * thenApply的线程名：main
         * null
         */
    }
}
单任务结果异常
  • handle()方法：有传参有返回值，上一个任务的执行结果或者执行期间抛出的异常（不影响当前任务处理）传递给回调方法，如果是正常执行则执行结果对应的值，异常为null；反之执行结果为null，打印异常信息，返回自定义结果。

示例代码：

public class ExecutorTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
public class ExecutorTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务一的线程名："+Thread.currentThread().getName());
            return "任务一";
        }).thenApply((p1) -> {
            System.out.println("thenCombine的线程名：" + Thread.currentThread().getName()+"，参数："+p1);
            Integer a = null;
            return String.valueOf(a *1);
        }).handle((result,erro)->{
            System.out.println("参数："+result+"，异常："+erro);
            return result;
        });
        System.out.println(completableFuture.get());
        /** Output:
         * 任务一的线程名：ForkJoinPool.commonPool-worker-1
         * thenCombine的线程名：main，参数：任务一
         * 参数：null，异常：java.util.concurrent.CompletionException: java.lang.NullPointerException
         * null
         */
    }
}
  • whenComplete()方法：有传参无返回值，与 handle()方法无差别，如果该任务正常执行，则get()方法返回上一个任务的执行结果，如果是执行异常，则get()方法抛出异常。

示例代码：

public class ExecutorTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务一的线程名："+Thread.currentThread().getName());
            return "任务一";
        }).thenApply((p1) -> {
            System.out.println("thenCombine的线程名：" + Thread.currentThread().getName()+"，参数："+p1);
            return "thenApply";
        }).whenComplete((result,erro)->{
            System.out.println("参数："+result+"，异常："+erro);
        });
        System.out.println(completableFuture.get());
        /** Output:
         * 任务一的线程名：ForkJoinPool.commonPool-worker-1
         * thenCombine的线程名：main，参数：任务一
         * 参数：thenApply，异常：null
         * thenApply
         */
    }
}
  • exceptionally()方法：有参数有返回值。指定某个任务执行异常时执行的回调方法，会将抛出异常作为参数传递到此方法，用此方法返回的结果进行处理。

示例代码：

public class ExecutorTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务一的线程名："+Thread.currentThread().getName());
            return "任务一";
        }).thenApply((p1) -> {
            System.out.println("thenCombine的线程名：" + Thread.currentThread().getName()+"，参数："+p1);
            Integer a= null;
            return a*1;
        }).exceptionally((result)->{
            System.out.println("thenCombine的线程名：" + Thread.currentThread().getName()+"，参数："+result);
            return 0;
        });
        System.out.println(completableFuture.get());
        /** Output:
         * 任务一的线程名：ForkJoinPool.commonPool-worker-1
         * thenCombine的线程名：main，参数：任务一
         * thenCombine的线程名：main，参数：java.util.concurrent.CompletionException: java.lang.NullPointerException
         * 0
         */
    }
}
双任务结果
  • thenCombine()方法：有传参有返回值，将两个任务的执行结果作为方法入参传递，返回自定义结果。

示例代码：

public class ExecutorTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        CompletableFuture<String> c1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务一的线程名："+Thread.currentThread().getName());
            return "任务一";
        });
        CompletableFuture<String> c2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务二的线程名："+Thread.currentThread().getName());
            return "任务二";
        });
        CompletableFuture<String> completableFuture = c2.thenCombine(c1, (r1, r2) -> {
            System.out.println("thenCombine的线程名：" + Thread.currentThread().getName() + "，参数1：" + r1 + "，参数2：" + r2);
            return r1 + r2;
        });
        System.out.println(completableFuture.get());
        /** Output:
         * 任务一的线程名：ForkJoinPool.commonPool-worker-1
         * 任务二的线程名：ForkJoinPool.commonPool-worker-1
         * thenCombine的线程名：main，参数1：任务二，参数2：任务一
         * 任务二任务一
         */
    }
}
  • thenAcceptBoth()方法：有传参无返回值，将两个任务的执行结果作为方法入参传递。

示例代码：

public class ExecutorTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        CompletableFuture<String> c1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务一的线程名："+Thread.currentThread().getName());
            return "任务一";
        });
        CompletableFuture<String> c2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务二的线程名："+Thread.currentThread().getName());
            return "任务二";
        });
        CompletableFuture<Void> completableFuture = c2.thenAcceptBoth(c1, (r1, r2) -> {
            System.out.println("thenCombine的线程名：" + Thread.currentThread().getName() + "，参数1：" + r1 + "，参数2：" + r2);
        });
        System.out.println(completableFuture.get());
        /** Output:
         * 任务一的线程名：ForkJoinPool.commonPool-worker-1
         * 任务二的线程名：ForkJoinPool.commonPool-worker-1
         * thenCombine的线程名：main，参数1：任务二，参数2：任务一
         * null
         */
    }
}
  • runAfterBoth()方法：无传参无返回值，将两个任务执行完后在执行当前任务。

示例代码：

public class ExecutorTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        CompletableFuture<String> c1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务一的线程名："+Thread.currentThread().getName());
            return "任务一";
        });
        CompletableFuture<String> c2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务二的线程名："+Thread.currentThread().getName());
            return "任务二";
        });
        CompletableFuture<Void> completableFuture = c2.runAfterBoth(c1, () -> {
            System.out.println("thenCombine的线程名：" + Thread.currentThread().getName());
        });
        System.out.println(completableFuture.get());
        /** Output:
         * 任务一的线程名：ForkJoinPool.commonPool-worker-1
         * 任务二的线程名：ForkJoinPool.commonPool-worker-1
         * thenCombine的线程名：main
         * null
         */
    }
}
任意任务结果
  • applyToEither()方法：有传参有返回值，将两个任务中先执行完的任务结果作为方法入参传递，返回自定义结果。

示例代码：

public class ExecutorTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        CompletableFuture<String> c1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务一的线程名："+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "任务一";
        });
        CompletableFuture<String> c2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务二的线程名："+Thread.currentThread().getName());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "任务二";
        });
        CompletableFuture<String> completableFuture = c2.applyToEither(c1, (r1) -> {
            System.out.println("thenCombine的线程名：" + Thread.currentThread().getName()+"，参数："+r1);
            return r1;
        });
        System.out.println(completableFuture.get());
        /** Output:
         * 任务一的线程名：ForkJoinPool.commonPool-worker-1
         * 任务二的线程名：ForkJoinPool.commonPool-worker-2
         * thenCombine的线程名：ForkJoinPool.commonPool-worker-1，参数：任务一
         * 任务一
         */
    }
}
  • acceptEither()方法：有传参无返回值，将两个任务中先执行完的任务结果作为方法入参传递。

示例代码：

public class ExecutorTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        CompletableFuture<String> c1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务一的线程名："+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "任务一";
        });
        CompletableFuture<String> c2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务二的线程名："+Thread.currentThread().getName());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "任务二";
        });
        CompletableFuture<Void> completableFuture = c2.acceptEither(c1, (r1) -> {
            System.out.println("thenCombine的线程名：" + Thread.currentThread().getName()+"，参数："+r1);
        });
        System.out.println(completableFuture.get());
        /** Output:
         * 任务一的线程名：ForkJoinPool.commonPool-worker-1
         * 任务二的线程名：ForkJoinPool.commonPool-worker-2
         * thenCombine的线程名：ForkJoinPool.commonPool-worker-1，参数：任务一
         * null
         */
    }
}
  • runAfterEither()方法：无传参无返回值，将两个任务执行完后在执行当前任务。

示例代码：

public class ExecutorTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        CompletableFuture<String> c1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务一的线程名："+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "任务一";
        });
        CompletableFuture<String> c2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务二的线程名："+Thread.currentThread().getName());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "任务二";
        });
        CompletableFuture<Void> completableFuture = c2.runAfterEither(c1, () -> {
            System.out.println("thenCombine的线程名：" + Thread.currentThread().getName());
        });
        System.out.println(completableFuture.get());
        /** Output:
         * 任务一的线程名：ForkJoinPool.commonPool-worker-1
         * 任务二的线程名：ForkJoinPool.commonPool-worker-2
         * thenCombine的线程名：ForkJoinPool.commonPool-worker-1
         * null
         */
    }
}

其它方法

  • isDone()方法：判断任务是否完成。三种完成情况：normally（正常执行完毕）、exceptionally（执行异常）、via cancellation（取消）
  • cancel(boolean mayInterruptIfRunning)()方法：取消任务，若一个任务未完成，则以CancellationException异常。其相关未完成的子任务也会以CompletionException结束
  • isCancelled()()方法：是否已取消，在任务正常执行完成前取消，才为true。否则为false。
  • 还有其它许多方法，有兴趣自行了解。

本章小结

通常，请谨慎地使用并发。 如果需要使用它，请尝试使用最现代的方法：并行流或 CompletableFutures 。

如果你的并发问题变得比高级 Java 构造所支持的问题更大且更复杂，请考虑使用专为并发设计的语言，仅在需要并发的程序部分中使用这种语言是有可能的。 在撰写本文时，JVM 上最纯粹的功能语言是 Clojure（Lisp 的一种版本）和 Frege（Haskell 的一种实现）。这些使你可以在其中编写应用程序的并发部分语言，并通过 JVM 轻松地与你的主要 Java 代码进行交互。 或者，你可以选择更复杂的方法，即通过外部功能接口（FFI）将 JVM 之外的语言与另一种为并发设计的语言进行通信。

无论使用特定的语言、库使得并发看起来多么简单，都要将其视为一种妖术，因为总是有东西会在你最不期望出现的时候咬你。

成为大佬先秃头
关注
专栏目录
Java中CompletableFuture异步编程
淡定_蜗牛的博客
02-28 1557
1.简介 本文是CompletableFuture类的功能和用例的指南- 作为Java 8 Concurrency API改进而引入。 2. Java中的异步计算 异步计算很难推理。通常我们希望将任何计算视为一系列步骤。但是在异步计算的情况下，表示为回调的动作往往分散在代码中或者深深地嵌套在彼此内部。当我们需要处理其中一个步骤中可能发生的错误时，情况变得更糟。 Future接口是Java 5中添加...
CompletableFuture 使用详解
大JAVA解决方案
08-04 778
1、 runAsync 和 supplyAsync方法 CompletableFuture 提供了四个静态方法来创建一个异步操作。 public static CompletableFuture<Void> runAsync(Runnable runnable) public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor) public static <U&g...
CompletableFuture详解
最新发布
weixin_43527947的博客
08-06 3316
在JAVA8开始引入了全新的类，它是Future接口的一个实现类。也就是在Future接口的基础上，额外封装提供了一些执行方法，用来解决Future使用场景中的一些不足，对流水线处理能力提供了支持。当我们需要进行异步处理的时候，我们可以通过方法，传入一个具体的要执行的处理逻辑函数，这样就轻松的完成了CompletableFuture的创建与触发执行。方法名称作用描述静态方法，用于构建一个对象，并异步执行传入的参数，允许执行函数有返回值runAsync静态方法，用于构建一个。
CompletableFuture的runAsync
热门推荐
Zhang Phil
07-13 2万+
CompletableFuture的runAsyncCompletableFuture的runAsync只是简单的异步执行一个线程，但是它将返回一个CompletableFuture，有了这个CompletableFuture，可以重新组装和调配，这是和一个普通Runnable不同之处。CompletableFuture future = CompletableFuture.runAsync(ne...
Java8 CompletableFuture 用法全解
tengtianshan的专栏
04-29 1110
@[toc] CompletableFuture实现了CompletionStage接口和Future接口，前者是对后者的一个扩展，增加了异步回调、流式处理、多个Future组合处理的能力，使Java在处理多任务的协同工作时更加顺畅便利。 一、创建异步任务 1、Future.submit 通常的线程池接口类ExecutorService，其中execute方法的返回值是void，即无法获取异步任务的执行状态，3个重载的submit方法的返回值是Future，可以据此获取任务执行的状态和结果，示...
Completablefuture用法总结
feeling good
10-22 329
Future接口有一定的局限性，比如，我们很难表述Future结果之间的依赖性，因此在Java8中引入了CompletableFuture，它针对Future做了改进，可以传入回调对象，当异步任务完成或者发生异常时，自动调用回调对象的回调方法。
lvyongsheng#AndroidAllGuide#重拾Java（5）-枚举1
07-25
一、基础知识 二、枚举是类类型 三、枚举的一些方法
【会计硕士】2021会计硕士基础知识：人民币大写写法.doc
11-11
会计硕士在备考过程中，了解并掌握人民币大写写法是一项重要的基础知识。这涉及到会计工作中处理各种票据和结算凭证的准确性、及时性和安全性。在填写这些金融文档时，必须遵循标准化和规范化的原则，确保要素完整、...
awesome-java-leetcode：具有Java解决方案的算法的LeetCode（正在更新）
01-29
我如今是一名Android开发人员，大学的我曾是一名ACMer，我一直认为数据结构和算法是作为一名程序员必须掌握和善于利用的，为了不让数据结构和算法淡出我的记忆，所以我打算重拾LeetCode之算法，语言选择的是Java，...
java核心知识点包含所有java核心技术
01-31
JAVA基础 SPRING原理 微服务 等等 java核心知识点从0到1全包括 JVM 所有知识点技术点 JAVA集合 JAVA多线程并发 JAVA基础 SPRING原理 微服务 等等java核心知识点从0到1全包括 JVM 所有知识点技术点 JAVA集合 JAVA多...
java404错误_初拾Java（问题一：404错误，页面找不到）
weixin_35056962的博客
02-13 2014
做测试尤其是想走自动化测试之路的人，怎么可以不会码代码？！怒了。。。再次开始拾起Java，坚持坚持！！！刚写了一个JSP页面，想在Myeclipse里面跑来试试，结果搞了半天出现以下错误：试着去跑index.jsp,没问题呀，浏览器可以显示的呀，然后就去百度各种导致页面找不到的原因，下面这位的解决方法挺全的，先收了。1．未部署Web应用2．URL输入错误a.查看URL的IP地址和端口号是否书写正确...
使用CompletableFuture.runAsync()来完成异步任务
涂作权的博客
11-23 3790
转自：https://blog.csdn.net/m0_46539364/article/details/122529287。
Java并发编程之CompletableFuture详解
FlyingFish868的博客
09-22 3945
在项目中经常会使用到CompletableFuture ，很多开源框架中也大量使用到了 CompletableFuture 。因此，专门写一篇文章来介绍这个 Java 8 才被引入的一个非常有用的用于异步编程的类。CompletableFuture 同时实现了 Future 和 CompletionStage 接口。
CompletableFuture用法详解
qq_36042938的博客
08-09 2771
小笔记
使用 CompletableFuture 异步组装数据
Addisoni
02-02 1322
使用 CompletableFuture 异步组装数据 一种快捷、优雅的异步组装数据方式 实际项目中经常遇到这种情况： 从多个表中查找到数据然后拼装成一个VO返回给前端。 这个过程有可能会非常耗时。因为最终每一条返回的VO数据是由多个表中的数据拼装而成，如果项目还是微服务需要从其他服务获取数据，那将会更加耗时，更加麻烦。简单的几十条、几百条数据单个线程跑起来可能没有什么压力，但是当数量达到成千...
CompletableFuture详解~CompletionStage
小强快跑~~
02-26 1442
CompletableFuture 分别实现两个接口 Future与 CompletionStage。 Future 接口大家都比较熟悉，这里主要讲讲 CompletionStage。 CompletableFuture 大部分方法来自CompletionStage 接口，正是因为这个接口，CompletableFuture才有如此强大功能。 想要理解 CompletionStage 接口，我们需要先了解任务的时序关系的。我们可以将任务时序关系分为以下几种： 串行执行关系 并行
【Java 8 新特性】Java CompletableFuture supplyAsync()详解
qq_45721579的博客
06-25 5174
【Java 8 新特性】Java CompletableFuture supplyAsync()
重拾经验概念：经验科学新基础的探索
"分化与统一:经验科学的新经验基础之可能性初探 (2012年)" 本文探讨了在科学哲学领域中的一个重要议题——经验科学的基础及其发展。经验科学，即基于观察和实验的科学，其核心在于通过实证方法获取知识。文章指出，...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值