JAVA异步编程-JDK-CompletableFuture实践与原理

最新推荐文章于 2025-11-27 08:12:46 发布
原创 最新推荐文章于 2025-11-27 08:12:46 发布 · 731 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

本文深入探讨了CompletableFuture在异步编程中的强大功能，包括其基本概念、实践案例及源码解析。通过丰富的代码示例，展示了如何创建线程池、执行异步任务、处理任务结果，以及组合多个任务进行复杂运算。同时，对CompletableFuture的异常处理机制进行了详细说明。

1.文章目录

  • ComPletableFuture概述
  • CompletableFuture实践
  • CompletableFuture主要源码导读

2.CompletableFuture概述

  • CompleatableFuture是对Future的增强，我们知道Future的局限性，CompleatableFuture可以通过编程方式显式设置计算结果和状态，并且可以作为一个计算阶段，当他完成时还能触发另一个函数/行为；
  • 当多个线程调用CompletableFuture的complete,cancel方式只有一个线程会成功；
  • CompletableFuture实现了CompletionStage接口方法：主要是当CompletableFuture任务结束后，同步使用任务来执行依赖任务结果的函数/行为
  • 所有异步的方法在没有执行Executor参数情况下，都是用ForkJoinPool.commonPool线程池来执行；
  • 所有实现CompletionStage的方法都是相互独立的实现，不会因为重载其他方法影响；
  • 另外：CompletableFuture的结果有一些任务依赖于此，利用的无锁栈结构（CAS实现），因此执行顺序和依赖顺序相反；

3.CompletableFuture实践

显式设置CompletableFuture结果


public class CompletableFutureTest {
    // 自定义线程池
    private final static int CPU_COUNT = Runtime.getRuntime().availableProcessors();

    private final static ThreadPoolExecutor POOL_EXECUTOR = new ThreadPoolExecutor(CPU_COUNT, 2 * CPU_COUNT, 1,
            TimeUnit.MINUTES, new LinkedBlockingQueue<>(5), new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] argv) throws ExecutionException, InterruptedException {
        CompletableFuture<String> completableFuture = new CompletableFuture<String>();
        POOL_EXECUTOR.execute(()->{
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        // 设置future结果
        System.out.println("---" + Thread.currentThread().getName() + " set future result --- ");
        completableFuture.complete("niuBi");

        // 等待异步执行结果
        System.out.println("main wait future result");
        System.out.println(completableFuture.get());
        System.out.println("main get future result");

        // 关闭线程池
        POOL_EXECUTOR.shutdown();
    }
}
  • 创建线程池，提交任务到异步线程池，主线程调用get等待线程执行完任务，会阻塞主线程；

基于CompletableFuture实现异步计算与结果转化

  • 基于runAsync系列方法实现无返回值的异步计算；
  • 异步打印日志，Dubbo异步存放配置信息，异步消息通知等模型
public class CompletableFutureTest {
    
    public static void runAsync() throws ExecutionException, InterruptedException {
        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("over");
            }
        });

        System.out.println(completableFuture.get());
    }
    public static void main(String[] argv) throws ExecutionException, InterruptedException {
       runAsync();
    }
}
  • future.get获取的是null,我们知道默认是ForkJoinPool.commonPool线程池，我们也可以自己实现线程池；
public class CompletableFutureTest {
    // 自定义线程池
    private final static int CPU_COUNT = Runtime.getRuntime().availableProcessors();

    private final static ThreadPoolExecutor POOL_EXECUTOR = new ThreadPoolExecutor(CPU_COUNT, 2 * CPU_COUNT, 1,
            TimeUnit.MINUTES, new LinkedBlockingQueue<>(5), new ThreadPoolExecutor.AbortPolicy());


    public static void runAsync() throws ExecutionException, InterruptedException {
        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("over");
            }
        }, POOL_EXECUTOR);

        System.out.println(completableFuture.get());
    }
    public static void main(String[] argv) throws ExecutionException, InterruptedException {

       runAsync();
    }
}
  • 基于supplyAsync系列方法实现有返回值的异步计算
  • future.get返回"niuBi",也可以转化为自定义线程池执行异步任务
public static void supplyAsync() throws ExecutionException, InterruptedException {
        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(new Supplier<String>() {

            @Override
            public String get() {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 返回异步计算
                return "niuBi";
            }
        });

        System.out.println(completableFuture.get());
    }

自定义线程池:完成有返回值异步计算

public class CompletableFutureTest {
    // 自定义线程池
    private final static int CPU_COUNT = Runtime.getRuntime().availableProcessors();

    private final static ThreadPoolExecutor POOL_EXECUTOR = new ThreadPoolExecutor(CPU_COUNT, 2 * CPU_COUNT, 1,
            TimeUnit.MINUTES, new LinkedBlockingQueue<>(5), new ThreadPoolExecutor.AbortPolicy());


  
    public static void supplyAsync() throws ExecutionException, InterruptedException {
        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(new Supplier<String>() {

            @Override
            public String get() {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 返回异步计算
                return "niuBi";
            }
        }, POOL_EXECUTOR);

        System.out.println(completableFuture.get());
    }
    public static void main(String[] argv) throws ExecutionException, InterruptedException {

       supplyAsync();
       POOL_EXECUTOR.shutdown();
    }
}
  • 基于thenRun实现异步任务A,执行完毕后，激活任务B,这种方式激活的异步任务B拿不到任务A的执行结果；
public static void thenRun() throws ExecutionException, InterruptedException {
        CompletableFuture<String> oneFuture = CompletableFuture.supplyAsync(new Supplier<String>() {

            @Override
            public String get() {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("one future end");
                // 返回异步结果
                return "hello, NiuBi";
            }
        });
        CompletableFuture<Void> twoFuture = oneFuture.thenRun(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("two Future end");
        });
        // 同步等待twoFuture结束
        System.out.println(twoFuture.get());
    }
  • 基于thenAccept实现异步任务A，执行完后，激活任务B,B获取A的结果搞事情；
  • future.get的结果为null；
public static void thenAccept() throws ExecutionException, InterruptedException {
        CompletableFuture<String> oneFuture = CompletableFuture.supplyAsync(new Supplier<String>() {

            @Override
            public String get() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("one future end");

                return "niuBi";
            }
        });
        CompletableFuture<Void> twoFuture = oneFuture.thenAccept(new Consumer<String>() {
            @Override
            public void accept(String result) {
                // 对oneFuture的结果操作
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("two future get one future result : " + result + " add ");
            }
        });

        System.out.println(twoFuture.get());
    }
  • 基于thenApply实现任务A，完成后，激活任务B执行，B可以拿到A的结果，并且我们可以获得B的结果
  • 默认的oneFuture以及回调事件twoFuture在ForkJoin线程池是同一线程，如果用自定义线程池，调度的线程可能不一样；

    public static void thenApply() throws ExecutionException, InterruptedException {
        CompletableFuture<String> oneFuture = CompletableFuture.supplyAsync(new Supplier<String>() {

            @Override
            public String get() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("one future end");

                return "niuBi";
            }
        });

        CompletableFuture<String> twoFuture = oneFuture.thenApply(
                // arg1：前任务的返回结果类型，arg2：回调函数的返回类型
                new Function<String, String>() {
            @Override
            public String apply(String preResult) {
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return preResult + " two future add";
            }
        });

        System.out.println(twoFuture.get());
    }
  • 基于whenComplete设置回调函数：当异步任务执行完毕后进行回调，不会阻塞调用线程；
public class CompletableFutureTestDubbo {

    private static final CountDownLatch  countDownLatch = new CountDownLatch(1);
    public static void main(String[] argv) throws InterruptedException {
        CompletableFuture<String> oneFuture = CompletableFuture.supplyAsync(new Supplier<String>() {

            @Override
            public String get() {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                countDownLatch.countDown();
                return "niuBi";
            }
        });

        oneFuture.whenComplete(new BiConsumer<String, Throwable>() {
            @Override
            public void accept(String s, Throwable throwable) {
                // 如果没有异常
                if (null == throwable){
                    System.out.println(s);
                } else {
                    throwable.printStackTrace();
                }
            }
        });

        countDownLatch.await();
    }
}
  • 多个CompletableFuture进行组合运算
  • 基于thenCompose实现当一个CompletableFuture执行完毕，执行另一个CompletableFuture
public class CompletableFutureTestDubbo {

    private static final CountDownLatch  countDownLatch = new CountDownLatch(1);
    public static CompletableFuture<String> doSomethingOne(String encodedCompanyId){
        return CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return encodedCompanyId;
            }
        });
    }

    public static CompletableFuture<String> doSomethingTwo(String companyId){
        return CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return companyId + "阿里云";
            }
        });
    }
    public static void main(String[] argv) throws InterruptedException, ExecutionException {
        CompletableFuture<String> completableFuture = doSomethingOne("123").thenCompose(id -> doSomethingTwo(id));
        System.out.println(completableFuture.get());
    }
}
  • 基于thenCombine实现：两个并发任务结束，使用两者的结果作为参数；
public class CompletableFutureTestDubbo {

    private static final CountDownLatch  countDownLatch = new CountDownLatch(1);
    public static CompletableFuture<String> doSomethingOne(String encodedCompanyId){
        return CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return encodedCompanyId;
            }
        });
    }

    public static CompletableFuture<String> doSomethingTwo(String companyId){
        return CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return companyId + "阿里云";
            }
        });
    }
    public static void main(String[] argv) throws InterruptedException, ExecutionException {
      
        CompletableFuture<Object> completableFuture = doSomethingOne("123").thenCombine(doSomethingTwo("456"), (oneResult, twoResult) -> {
                return oneResult + ":" + twoResult;
        });
        System.out.println(completableFuture.get());
    }
}
  • 基于AllOf等待所有并发任务结束
public class CompletableFutureTestDubbo {

    private static final CountDownLatch  countDownLatch = new CountDownLatch(1);
    public static CompletableFuture<String> doSomethingOne(String encodedCompanyId){
        return CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("do SomethingOne");
                return encodedCompanyId;
            }
        });
    }

    public static CompletableFuture<String> doSomethingTwo(String companyId){
        return CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("do SomethingTwo");
                return companyId + "阿里云";
            }
        });
    }
    public static void main(String[] argv) throws InterruptedException, ExecutionException {
    
        List<CompletableFuture<String>> futureList = new ArrayList<>();
        futureList.add(doSomethingOne("111"));
        futureList.add(doSomethingOne("222"));
        futureList.add(doSomethingOne("333"));
        futureList.add(doSomethingTwo("444"));
        futureList.add(doSomethingTwo("555"));
        CompletableFuture<Void> completableFuture = CompletableFuture.allOf(futureList.toArray(new CompletableFuture[futureList.size()]));
        System.out.println(completableFuture.get());
    }
}
  • 基于anyof实现当任务集合中一个任务结束就会返回，但是任务都会运行完；
public class CompletableFutureTestDubbo {

    private static final CountDownLatch  countDownLatch = new CountDownLatch(1);
    public static CompletableFuture<String> doSomethingOne(String encodedCompanyId){
        return CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("do SomethingOne");
                return encodedCompanyId;
            }
        });
    }

    public static CompletableFuture<String> doSomethingTwo(String companyId){
        return CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("do SomethingTwo");
                return companyId + "阿里云";
            }
        });
    }
    public static void main(String[] argv) throws InterruptedException, ExecutionException {
   
        List<CompletableFuture<String>> futureList = new ArrayList<>();
        futureList.add(doSomethingOne("111"));
        futureList.add(doSomethingOne("222"));
        futureList.add(doSomethingOne("333"));
        futureList.add(doSomethingTwo("444"));
        futureList.add(doSomethingTwo("555"));
        CompletableFuture<Object> completableFuture = CompletableFuture.anyOf(futureList.toArray(new CompletableFuture[futureList.size()]));
        System.out.println(completableFuture.get());
    }

异常处理

  • 当任务的处理过程出现异常，如何处理;
  • 如下代码，我们抛出异常，导致future.get一直阻塞，线上操作是致命的；
public class CompletableFutureExpectionTest {
    public static void main(String[] argv) throws ExecutionException, InterruptedException {
        CompletableFuture<String> completableFuture = new CompletableFuture<>();
        new Thread(()->{
            try {
                if (true){
                    throw new RuntimeException("error cause");
                }
                completableFuture.complete("success");
            }catch (Exception e) {

            }
            System.out.println(Thread.currentThread().getName() + " set result");
        }, "threadA").start();

        System.out.println(completableFuture.get());
    }
}
  • completeExceptionAlly方法处理异常情况：如下代码，会打印异常信息
public class CompletableFutureExpectionTest {
    public static void main(String[] argv) throws ExecutionException, InterruptedException {
        CompletableFuture<String> completableFuture = new CompletableFuture<>();
        new Thread(()->{
            try {
                if (true){
                    throw new RuntimeException("error cause");
                }
                completableFuture.complete("success");
            }catch (Exception e) {
                completableFuture.completeExceptionally(e);
            }
            System.out.println(Thread.currentThread().getName() + " set result");
        }, "threadA").start();

        //System.out.println(completableFuture.exceptionally(t-> "defalut").get());
         System.out.println(completableFuture.get());
    }
}
  • 以上是对于CompletableFuture的实践，具体业务可以更加灵活的扩展，结合应用；

4.CompletableFuture源码导读

基本属性：保存变量偏移量，CAS操作修改；

// Unsafe mechanics
    private static final sun.misc.Unsafe UNSAFE;
    private static final long RESULT;
    private static final long STACK;
    private static final long NEXT;
    static {
        try {
            final sun.misc.Unsafe u;
            UNSAFE = u = sun.misc.Unsafe.getUnsafe();
            Class<?> k = CompletableFuture.class;
            RESULT = u.objectFieldOffset(k.getDeclaredField("result"));
            STACK = u.objectFieldOffset(k.getDeclaredField("stack"));
            NEXT = u.objectFieldOffset
                (Completion.class.getDeclaredField("next"));
        } catch (Exception x) {
            throw new Error(x);
        }
    }

reportget

 private static <T> T reportGet(Object r)
        throws InterruptedException, ExecutionException {
         // 如果r为null则抛出异常
        if (r == null) // by convention below, null means interrupted
            throw new InterruptedException();
        // 如果是异常类
        if (r instanceof AltResult) {
            Throwable x, cause;
            // 根据异常类型，抛出异常
            if ((x = ((AltResult)r).ex) == null)
                return null;
            if (x instanceof CancellationException)
                throw (CancellationException)x;
            if ((x instanceof CompletionException) &&
                (cause = x.getCause()) != null)
                x = cause;
            throw new ExecutionException(x);
        }
        // 转化结果
        @SuppressWarnings("unchecked") T t = (T) r;
        return t;
    }

线程池，Task运行本质

 // 默认为forkjoinPool  
private static final Executor asyncPool = useCommonPool ?
        ForkJoinPool.commonPool() : new ThreadPerTaskExecutor();

    // Task本质，创建线程运行

    static final class ThreadPerTaskExecutor implements Executor {
        public void execute(Runnable r) { new Thread(r).start(); }
    }

Completion代表一个异步计算节点

abstract static class Completion extends ForkJoinTask<Void>
        implements Runnable, AsynchronousCompletionTask {
       // 节点链
        volatile Completion next;      // Treiber stack link

       
        abstract CompletableFuture<?> tryFire(int mode);

        /** Returns true if possibly still triggerable. Used by cleanStack. */
        abstract boolean isLive();
        //task的运行，其实就是方法中写的run任务
        public final void run()                { tryFire(ASYNC); }
        public final boolean exec()            { tryFire(ASYNC); return true; }
        public final Void getRawResult()       { return null; }
        public final void setRawResult(Void v) {}
    }

runAsync(Runnable runnable):

 public static CompletableFuture<Void> runAsync(Runnable runnable) {
        return asyncRunStage(asyncPool, runnable);
    }

  static CompletableFuture<Void> asyncRunStage(Executor e, Runnable f) {
        // 判空校验
        if (f == null) throw new NullPointerException();
        // 创建返回对象
        CompletableFuture<Void> d = new CompletableFuture<Void>();
         // 线程池执行
        e.execute(new AsyncRun(d, f));
        //返回future
        return d;
    }

   static final class AsyncRun extends ForkJoinTask<Void>
            implements Runnable, AsynchronousCompletionTask {
        CompletableFuture<Void> dep; Runnable fn;
        AsyncRun(CompletableFuture<Void> dep, Runnable fn) {
            this.dep = dep; this.fn = fn;
        }

        public final Void getRawResult() { return null; }
        public final void setRawResult(Void v) {}
        public final boolean exec() { run(); return true; }

        public void run() {
            CompletableFuture<Void> d; Runnable f;
            if ((d = dep) != null && (f = fn) != null) {
                dep = null; fn = null;
                // 任务没有完成
                if (d.result == null) {
                    try {
                   // 运行
                        f.run();
                    //设置返回结果null
                        d.completeNull();
                    } catch (Throwable ex) {
                        d.completeThrowable(ex);
                    }
                }
                 //弹出依赖当前结果的节点，执行
                d.postComplete();
            }
        }
    }

CompletableFuture<U> supplyAsync(Supplier<U> supplier):有返回结果

    public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier) {
        return asyncSupplyStage(asyncPool, supplier);
    }

    static <U> CompletableFuture<U> asyncSupplyStage(Executor e,
                                                     Supplier<U> f) {
        if (f == null) throw new NullPointerException();
         // 创建future对象
        CompletableFuture<U> d = new CompletableFuture<U>();
         // 线程池执行AsyncSupply对象（包装f)
        e.execute(new AsyncSupply<U>(d, f));
        // 返回future
            return d;
        }

         public void run() {
            CompletableFuture<T> d; Supplier<T> f;
            if ((d = dep) != null && (f = fn) != null) {
                dep = null; fn = null;
                if (d.result == null) {
                    try {
                        // f.get获取值
                        d.completeValue(f.get());
                    } catch (Throwable ex) {
                        d.completeThrowable(ex);
                    }
                }
                // 通知依赖节点
                d.postComplete();
            }
  • 介绍l主要的运行任务方法;

int  getNumberOfDependents:获取依赖该节点的任务数

 // 获取依赖该节点的任务数 
public int getNumberOfDependents() {
        int count = 0;
        // 遍历一遍
        for (Completion p = stack; p != null; p = p.next)
            ++count;
        return count;
    }
  • 基本的方法实现已经结束；

4.总结

  • CompletableFuture对异步编程的支持很强，可以根据我们的业务进行灵活的运用；在框架中异步思想的运行很多，因此对CompletableFuture的运用要非常熟悉，后续我们对CompletableFuture的所有方法细节实现进行导读，如何通知其他依赖节点，then系列方法执行后，是如何保存节点信息，异常情况，其他信息如何处理等；
Java多线程系列--Future接口和CompletableFuture类
打酱油的葫芦娃
03-02 6485
Future接口 Future接口是Java 1.5引入的新特性，可以方便的用于异步结果的获取。 接口定义如下: public interface Future<V> { // 取消提交的异步任务 boolean cancel(boolean mayInterruptIfRunning); // 判断异步任务是否已取消 boolean isCancelled(); // 判断异步任务是否已完成 boolean isDone(); /
Java8异步类CompletableFuture详解
CharlesYooSky的博客
09-01 2650
JDK8引入了一个新的类CompletableFuture
Java 之 异步 CompletableFuture
weixin_44513658的博客
05-04 1348
java 异步 CompletableFuture 上手
CompletableFuture原理与用法
旷野历程
01-15 2305
在Java中CompletableFuture用于异步编程，异步通常意味着非阻塞，运行任务单独的线程，与主线程隔离。并且通过回调可以在主线程中得到异步任务的执行状态，是否完成和异常等信息。通过这种方式，主线程不会被阻塞，不需要一直等到子线程完成。主线程可以并行的执行其他任务。使用这种并行方式，可以极大的提高程序的性能。CompletableFuture 可以从全局的 ForkJoinPool.commonPool() 获得一个线程中执行这些任务。
CompletableFuture核心原理
最新发布
wobenwoxiangfei的博客
11-27 289
非阻塞：通过回调链和 CAS 实现无锁并发。灵活编排：支持链式调用、并行组合、异常传播。高效资源管理：结合 ForkJoinPool 优化线程利用率。其设计思想广泛应用于响应式编程和微服务异步调用场景，是 Java 并发编程的重要工具。
JAVA异步任务-CompletableFuture
qq_33479841的博客
10-14 1132
在jdk1.8中，引入了CompletableFuture，它扩展了Future和CompletionStage，可以在任务完成后触发回调，实现异步调用。在此之前若要设置回调一般会使用guava的ListenableFuture，但引入回调之后会陷入无穷的回调地狱中，导致编码难以阅读和理解。CompletableFuture对Future进行了扩展，可以通过设置回调的方式处理计算结果，同时也支持组合，支持任务编排，在一定程度上解决了回调地狱和代码难以阅读问题。
Java——CompletableFuture原理
看不懂的男孩的博客
10-07 1101
CompletableFuture是Future的功能增强实现，不用阻塞主线程即可操作后续异步任务，其中的原理是怎样的呢？
Java的CompletableFuture实现原理
猪猪
12-23 1355
Java的是Java 8中引入的一个用于异步编程的类，它实现了Future和接口，提供了强大的异步编程能力。以下是。
Java异步编程利器：CompletableFuture详解
who_im_i的博客
11-05 2267
‌CompletableFuture‌是Java 8中引入的一个类，它实现了Future和CompletionStage接口，用于支持异步编程和非阻塞操作。CompletableFuture提供了丰富的API，使得并发任务的处理变得简单而高效，能够轻松创建、组合和链式调用异步操作，无需关心底层线程管理，从而提升了程序的响应速度和资源利用率‌。
Java 异步编程进阶：CompletableFuture 完全指南
dazhong2012的专栏
04-19 3284
CompletableFuture 是 Java 8 引入的一个类，用于异步编程。它实现了 Future 接口，并添加了许多额外的方法，使得异步编程更加灵活和强大。与传统的 Future 相比，CompletableFuture 允许我们显式地完成一个异步任务，而不必等待其完成。
异步编程探究JDK中的CompletableFuture(满足不同场景需求)
天涯芳草
04-14 336
CompletableFuture是一个通过编程方式显示地设置计算结果和状态以便让任务接收的Future，并且其可以作为一个CompletableStage(计算阶段),当它的计算完成时可以触发一个函数或者行为;当多个线程企图调用一个CompletableFuture的complete,cancel方发时只会有一个线程会成功。 ...
Java8新的异步编程方式CompletableFuture实现
08-26
主要介绍了Java8新的异步编程方式CompletableFuture实现，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
并发编程(十六)-CompletableFuture原理与实践
及时当勉励，岁月不待人
06-27 2508
并发编程(十六)-CompletableFuture原理与实践
CompletableFuture实现原理及应用
weixin_40322495的博客
05-15 796
CompletableFuture由Java 8提供，是实现异步化的工具类，上手难度较低，且功能强大，支持通过函数式编程的方式对各类操作进行组合编排。相比于ListenableFuture，CompletableFuture有效提升了代码的可读性。 CompletableFuture中包含两个字段：result和stack。result用于存储当前CF的结果，stack（Completion）表示当前CF完成后需要触发的依赖动作（Dependency Actions），去触发依赖它的CF的计算，依赖动作可
八、异步编程
耀耀zz的博客
03-01 823
本文介绍异步编程FutureTask和CompletableFuture应用和源码分析。
Java 异步编程——异步编排(CompletableFuture)
longool的博客
10-21 2235
CompletableFuture 是 JDK8 提出的一个支持非阻塞的多功能的 Future，提供了一种强大的异步编程模型，实现了 Future 接口；在使用 Future 的过程中，大家会发现 Future 有两种方式返回结果的方式CompletableFuture 接口提供了非常多的方法用于编排异步任务，基本每个方法都有两套实现，Async 版本的函数与非 Async 版本的函数。
CompletableFuture 详解与原理
weixin_39676449的博客
09-13 1534
一、Future的使用： 1、Future含义： CompletableFuture实现了Future接口; Future是Java5新加的一个接口，它提供了一种异步并行计算的功能。如果主线程需要执行一个很耗时的计算任务，我们就可以通过future把这个任务放到异步线程中执行。主线程继续处理其他任务，处理完成后，再通过Future获取计算结果 2、使用实例： 假设我们有两个任务服务，一个查询用户基本信息，一个是查询用户勋章信息： public class UserInfoService { pub
completableFuture原理及使用
iverson2010112228的专栏
12-21 614
背景 Java8函数式编程函数 CompleStage接口方法介绍及分类 CompletableFuture实现原理及源码 优点和缺点 参考
Java并发编程之异步Future机制的原理和实现
莫名的拉风的博客
08-23 910
Java并发编程之异步Future机制的原理和实现           项目中经常有些任务需要异步(提交到线程池中)去执行，而主线程往往需要知道异步执行产生的结果，这时我们要怎么做呢？用runnable是无法实现的，我们需要用callable看下面的代码： import java.util.concurrent.Callable; import java.util.concurrent...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值