Future和CompletableFuture的使用

最新推荐文章于 2024-05-28 18:03:23 发布
最新推荐文章于 2024-05-28 18:03:23 发布
阅读量283 收藏 1
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44130094/article/details/124491515
版权

1、future使用

public class FutureDemo {
    private static Logger logger = LoggerFactory.getLogger(FutureDemo.class);
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask futureTask = new FutureTask(()->{
            logger.info("futureTask ->callable 执行！！！");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"返回任务结果");

        new Thread(futureTask).start();
        /**
         * 获取结果
         */
        //futureTask.get();
        /**
         * 是否执行完成
         */
        //futureTask.isDone();
        System.out.println(futureTask.get());
    }
}

2、CompletionService


import java.util.concurrent.*;

public class CompletionServiceDemo {
    private static ThreadPoolExecutor threadPoolExecutor =
            new ThreadPoolExecutor(10,20,10, TimeUnit.SECONDS,new LinkedBlockingQueue<>());

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        CompletionService<Integer> completionService = new ExecutorCompletionService<Integer>(threadPoolExecutor);

        completionService.submit(()->{
            try {
                Thread.sleep(800);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },800);

        completionService.submit(()->{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },1000);
        completionService.submit(()->{
            try {
                Thread.sleep(15000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },1500);

        for (int i = 0; i < 3; i++) {
            /**
             * take获取先执行出来的数据
             */
            Integer integer = completionService.take().get();
            System.out.println(integer);

        }
        threadPoolExecutor.shutdown();
    }
}

3、CompletableFuture 简单使用

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.CompletableFuture;


public class CompletableFutureDemo {
    private static ThreadPoolTaskExecutor threadPoolTaskExecutor;
    static {
        threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
        threadPoolTaskExecutor.setCorePoolSize(10);
        threadPoolTaskExecutor.setMaxPoolSize(10);
        threadPoolTaskExecutor.setThreadNamePrefix("CompletableFutureDemo-");
        threadPoolTaskExecutor.setQueueCapacity(1000);
        threadPoolTaskExecutor.setKeepAliveSeconds(60);
        threadPoolTaskExecutor.initialize();
    }

    private static Logger logger = LoggerFactory.getLogger(CompletableFutureDemo.class);

    public static void main(String[] args) {

        /**
         * 依赖关系
         * 1、thenApply() 把前面异步任务的结果，交给后面的Future
         * 2、thenCompose() 连接2个有依赖关系的任务
         *
         * and聚合关系
         * 1、thenCombine()任务合并，有返回值
         * 2、thenAcceptBoth() 2个任务都完成后将结果交给thenAcceptBoth（）消耗
         * 3、runAfterBoth() 2个任务都执行完成后，执行下一步操作
         *
         * or聚合关系
         * 1、applyToEither() 2个任务谁执行的快就使用哪个结果，有返回值
         * 2、acceptEither() 2个任务谁执行的快就使用哪个结果，没有返回值
         * 3、runAfterEither() 任意一个任务执行完成，进行下一步操作
         *
         * 并行执行
         * anyOf() 和 allOf()
         */
        CompletableFuture<Void> voidCompletableFuture = CompletableFuture.runAsync(() -> {
            logger.info("异步没有返回值！！");
        },threadPoolTaskExecutor);

        CompletableFuture<String> stringCompletableFuture = CompletableFuture.supplyAsync(() -> {
            logger.info("异步有返回值！！");
            return "aaaa";
        }, threadPoolTaskExecutor);
        logger.info("异步返回值[{}]",stringCompletableFuture.join());

        threadPoolTaskExecutor.shutdown();

    }

4、CompletableFuture 执行完成后执行（whenComplete()或 whenCompleteAsync()）

package com.example.jucdemo.future;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.CompletableFuture;
import java.util.function.BiConsumer;

/**
 * 依赖关系
 * 1、thenApply() 把前面异步任务的结果，交给后面的Future
 * 2、thenCompose() 连接2个有依赖关系的任务
 *
 * and聚合关系
 * 1、thenCombine()任务合并，有返回值
 * 2、thenAcceptBoth() 2个任务都完成后将结果交给thenAcceptBoth（）消耗
 * 3、runAfterBoth() 2个任务都执行完成后，执行下一步操作
 *
 * or聚合关系
 * 1、applyToEither() 2个任务谁执行的快就使用哪个结果，有返回值
 * 2、acceptEither() 2个任务谁执行的快就使用哪个结果，没有返回值
 * 3、runAfterEither() 任意一个任务执行完成，进行下一步操作
 *
 * 并行执行
 * anyOf() 和 allOf()
 */
public class CompletableFutureDemo {
    private static ThreadPoolTaskExecutor threadPoolTaskExecutor;
    static {
        threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
        threadPoolTaskExecutor.setCorePoolSize(10);
        threadPoolTaskExecutor.setMaxPoolSize(10);
        threadPoolTaskExecutor.setThreadNamePrefix("CompletableFutureDemo-");
        threadPoolTaskExecutor.setQueueCapacity(1000);
        threadPoolTaskExecutor.setKeepAliveSeconds(60);
        threadPoolTaskExecutor.initialize();
    }

    private static Logger logger = LoggerFactory.getLogger(CompletableFutureDemo.class);

    public static void main(String[] args) {


        CompletableFuture<Void> voidCompletableFuture = CompletableFuture.runAsync(() -> {
            logger.info("异步没有返回值！！");
        },threadPoolTaskExecutor);

        /**
         * 执行完成后执行 whenComplete()或者 whenCompleteAsync()方法
         * 异常之后执行 exceptionally()
         */
        CompletableFuture<String> stringCompletableFuture = CompletableFuture.supplyAsync(() -> {
            logger.info("异步有返回值！！");
            return "aaaa";
        }, threadPoolTaskExecutor);

        /**
         * 执行完成后异步执行 另一个线程执行
         */
        stringCompletableFuture.whenCompleteAsync(new BiConsumer<String, Throwable>() {
            @Override
            public void accept(String s, Throwable throwable) {
                logger.info("supplyAsync执行完成后获取返回值[{}]",s);
            }
        },threadPoolTaskExecutor);
        /**
         * 同步执行  执行stringCompletableFuture的线程执行
         */
        stringCompletableFuture.whenComplete(new BiConsumer<String, Throwable>() {
            @Override
            public void accept(String s, Throwable throwable) {
                logger.info("supplyAsync执行完成后获取返回值[{}]",s);
            }
        });
        
        logger.info("异步返回值[{}]",stringCompletableFuture.join());

        threadPoolTaskExecutor.shutdown();

    }


}

5、CompletableFuture 执行抛异常执行


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.function.BiConsumer;
import java.util.function.Function;

/**
 * 依赖关系
 * 1、thenApply() 把前面异步任务的结果，交给后面的Future
 * 2、thenCompose() 连接2个有依赖关系的任务
 *
 * and聚合关系
 * 1、thenCombine()任务合并，有返回值
 * 2、thenAcceptBoth() 2个任务都完成后将结果交给thenAcceptBoth（）消耗
 * 3、runAfterBoth() 2个任务都执行完成后，执行下一步操作
 *
 * or聚合关系
 * 1、applyToEither() 2个任务谁执行的快就使用哪个结果，有返回值
 * 2、acceptEither() 2个任务谁执行的快就使用哪个结果，没有返回值
 * 3、runAfterEither() 任意一个任务执行完成，进行下一步操作
 *
 * 并行执行
 * anyOf() 和 allOf()
 */
public class CompletableFutureDemo {
    private static ThreadPoolTaskExecutor threadPoolTaskExecutor;
    static {
        threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
        threadPoolTaskExecutor.setCorePoolSize(10);
        threadPoolTaskExecutor.setMaxPoolSize(10);
        threadPoolTaskExecutor.setThreadNamePrefix("CompletableFutureDemo-");
        threadPoolTaskExecutor.setQueueCapacity(1000);
        threadPoolTaskExecutor.setKeepAliveSeconds(60);
        threadPoolTaskExecutor.initialize();
    }

    private static Logger logger = LoggerFactory.getLogger(CompletableFutureDemo.class);

    public static void main(String[] args) {
        /**
         * 执行完成后执行 whenComplete()或者 whenCompleteAsync()方法
         * 异常之后执行 exceptionally()
         */
        CompletableFuture<String> stringCompletableFuture = CompletableFuture.supplyAsync(() -> {
            logger.info("异步有返回值！！");
            List list = null;
            list.add("1");
            return "aaaa";
        }, threadPoolTaskExecutor);

        /**
         * 执行完成后异步执行 另一个线程执行
         */
//        stringCompletableFuture.whenCompleteAsync(new BiConsumer<String, Throwable>() {
//            @Override
//            public void accept(String s, Throwable throwable) {
//                logger.info("supplyAsync执行完成后获取返回值[{}]",s);
//            }
//        },threadPoolTaskExecutor);
        /**
         * 同步执行  执行stringCompletableFuture的线程执行
         */
        stringCompletableFuture.whenComplete(new BiConsumer<String, Throwable>() {
            @Override
            public void accept(String s, Throwable throwable) {
                logger.info("supplyAsync执行完成后获取返回值[{}]",s);
            }
        });
         /**
         * 异常执行
         */
        CompletableFuture<String> exceptionally = stringCompletableFuture.exceptionally(new Function<Throwable, String>() {
            @Override
            public String apply(Throwable throwable) {
                logger.info("异常【{}】", throwable.getMessage());
                return throwable.getMessage();
            }
        });
        logger.info("异常返回值[{}]",exceptionally.join());

        logger.info("异步返回值[{}]",stringCompletableFuture.join());

        threadPoolTaskExecutor.shutdown();

    }

6、CompletableFuture上一个执行完成的返回值作为下一个的入参（thenApply()/thenApplyAsync()）


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.CompletableFuture;


public class CompletableFutureDemo1 {
    private static ThreadPoolTaskExecutor threadPoolTaskExecutor;

    static {
        threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
        threadPoolTaskExecutor.setCorePoolSize(10);
        threadPoolTaskExecutor.setMaxPoolSize(10);
        threadPoolTaskExecutor.setThreadNamePrefix("CompletableFutureDemo-");
        threadPoolTaskExecutor.setQueueCapacity(1000);
        threadPoolTaskExecutor.setKeepAliveSeconds(60);
        threadPoolTaskExecutor.initialize();
    }

    private static Logger logger = LoggerFactory.getLogger(CompletableFutureDemo1.class);

    public static void main(String[] args) {
        /**
         * 上一个结果的做为下一个任务的入参
         * thenApply() 同步
         * 或
         * thenApplyAsync() 异步
         */
        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
            logger.info("异步有返回值！！");
            return "Hello";
        }, threadPoolTaskExecutor).thenApply(h->{
            return h + "World";
        });
        /*CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
            logger.info("异步有返回值！！");
            return "Hello";
        }, threadPoolTaskExecutor)
                .thenApply(h->{
            return h + "World";
        }).thenApply(w->{
            return w+".";
        });*/
        logger.info("{}",completableFuture.join());

        /**
         * 异步
         */
        CompletableFuture<String> async = CompletableFuture.supplyAsync(() -> {
            logger.info("异步有返回值2！！");
            return "Hello";
        }, threadPoolTaskExecutor).thenApplyAsync(h->{
            return h + "World";
        },threadPoolTaskExecutor);

        logger.info("{}",async.join());

        threadPoolTaskExecutor.shutdown();
    }
}

7、thenCombine() 任务合并

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

public class CompletableFutureDemo {
    private static Logger logger = LoggerFactory.getLogger(CompletableFutureDemo.class);
    private static ThreadPoolTaskExecutor threadPoolTaskExecutor;

    static {
        threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
        threadPoolTaskExecutor.setCorePoolSize(10);
        threadPoolTaskExecutor.setMaxPoolSize(10);
        threadPoolTaskExecutor.setThreadNamePrefix("CompletableFutureDemo-");
        threadPoolTaskExecutor.setQueueCapacity(1000);
        threadPoolTaskExecutor.setKeepAliveSeconds(60);
        threadPoolTaskExecutor.initialize();
    }



    public static void main(String[] args) {
        /**
         * 上一个结果的做为下一个任务的入参
         * thenApply() 同步
         * 或
         * thenApplyAsync() 异步
         *
         * thenCombine()合并两个结果，上一个执行完成的和当前执行完成的 z上一个结果 e当前结果
         */
        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
            logger.info("异步有返回值！！");
            return "Hello";
        }, threadPoolTaskExecutor).thenApply(h->{
            return h + "World！";
        }).thenCombine(CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "你好 世界";
        },threadPoolTaskExecutor),(z,e)->{
            return z + e;
        });
        logger.info("{}",completableFuture.join());
        threadPoolTaskExecutor.shutdown();
    }


}

8、applyToEitherAsync() 异步 哪个先执行完成，就用哪个结果


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.CompletableFuture;

public class CompletableFutureDemo {
    private static Logger logger = LoggerFactory.getLogger(CompletableFutureDemo.class);
    private static ThreadPoolTaskExecutor threadPoolTaskExecutor;

    static {
        threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
        threadPoolTaskExecutor.setCorePoolSize(10);
        threadPoolTaskExecutor.setMaxPoolSize(10);
        threadPoolTaskExecutor.setThreadNamePrefix("CompletableFutureDemo-");
        threadPoolTaskExecutor.setQueueCapacity(1000);
        threadPoolTaskExecutor.setKeepAliveSeconds(60);
        threadPoolTaskExecutor.initialize();
    }


    public static void main(String[] args) {
        /**
         * applyToEitherAsync() 异步 哪个先执行完成，就用哪个结果
         * applyToEither() 同步
         */
        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
                    logger.info("111公交车正在赶来");
                    return "111公交车到了";
                }, threadPoolTaskExecutor)
                .applyToEither(CompletableFuture.supplyAsync(() -> {
                    logger.info("222公交车正在赶来");

                    return "222公交车到了";
                }, threadPoolTaskExecutor), (s) -> {
                    if (s.startsWith("111")) {
                        logger.info("111公交车到了");
                    }
                    if (s.startsWith("222")) {
                        logger.info("222公交车到了");
                    }
                    return s;
                });
//        logger.info("{}",completableFuture.join());
        threadPoolTaskExecutor.shutdown();

    }

}

9、thenAccept() | thenAcceptAsync()没有返回结果的 在thenAccept中获取上一个参数直接使用


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.CompletableFuture;

public class CompletableFutureDemo {
    private static Logger logger = LoggerFactory.getLogger(CompletableFutureDemo.class);
    private static ThreadPoolTaskExecutor threadPoolTaskExecutor;

    static {
        threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
        threadPoolTaskExecutor.setCorePoolSize(10);
        threadPoolTaskExecutor.setMaxPoolSize(10);
        threadPoolTaskExecutor.setThreadNamePrefix("CompletableFutureDemo-");
        threadPoolTaskExecutor.setQueueCapacity(1000);
        threadPoolTaskExecutor.setKeepAliveSeconds(60);
        threadPoolTaskExecutor.initialize();
    }


    public static void main(String[] args) {
        /**
         * thenAccept() 没有返回结果的  在thenAccept中获取上一个参数直接使用
         *
         * thenAcceptAsync() 异步
         */
        CompletableFuture<Void> completableFuture = CompletableFuture.supplyAsync(() -> {
            int a = 2;
            logger.info("第一个值：{}", a);

            return a;
        }, threadPoolTaskExecutor).thenAccept(s -> {
            logger.info("倍数：{}", s * s);
        });
        /**
         * 异步
         */
        CompletableFuture<Void> completableFutureAsync = CompletableFuture.supplyAsync(() -> {
                    int a = 2;
                    logger.info("第一个值：{}", a);
                    return a;
                }, threadPoolTaskExecutor)
                .thenAcceptAsync(s -> {
                    logger.info("倍数：{}", s * s);
                }, threadPoolTaskExecutor);


    }

}

10、thenAcceptBoth|thenAcceptBothAsync() 对2个CompletableFuture的结果进行操作

package com.example.jucdemo.future;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.CompletableFuture;

public class CompletableFutureDemo {
    private static Logger logger = LoggerFactory.getLogger(CompletableFutureDemo.class);
    private static ThreadPoolTaskExecutor threadPoolTaskExecutor;

    static {
        threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
        threadPoolTaskExecutor.setCorePoolSize(10);
        threadPoolTaskExecutor.setMaxPoolSize(10);
        threadPoolTaskExecutor.setThreadNamePrefix("CompletableFutureDemo-");
        threadPoolTaskExecutor.setQueueCapacity(1000);
        threadPoolTaskExecutor.setKeepAliveSeconds(60);
        threadPoolTaskExecutor.initialize();
    }


    public static void main(String[] args) {
        /**
         * thenAcceptBothAsync() 异步，对2个CompletableFuture的结果进行操作
         * thenAcceptBoth() 同步
         */
        CompletableFuture<Integer> integerCompletableFuture1 = CompletableFuture.supplyAsync(() -> {
            int a = 2;
            logger.info("第一个值：{}", a);
            return a;
        }, threadPoolTaskExecutor);

        CompletableFuture<Integer> integerCompletableFuture2 = CompletableFuture.supplyAsync(() -> {
            int a = 3;
            logger.info("第二个值：{}", a);
            return a;
        }, threadPoolTaskExecutor);

       integerCompletableFuture1.thenAcceptBothAsync(integerCompletableFuture2, (s1, s2) -> {
            logger.info("求和：{}", s1 + s2);
        }, threadPoolTaskExecutor);
        threadPoolTaskExecutor.shutdown();
    }

}

11、anyOf() 有一个返回即可

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.CompletableFuture;

public class CompletableFutureDemo {
    private static Logger logger = LoggerFactory.getLogger(CompletableFutureDemo.class);
    private static ThreadPoolTaskExecutor threadPoolTaskExecutor;

    static {
        threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
        threadPoolTaskExecutor.setCorePoolSize(10);
        threadPoolTaskExecutor.setMaxPoolSize(10);
        threadPoolTaskExecutor.setThreadNamePrefix("CompletableFutureDemo-");
        threadPoolTaskExecutor.setQueueCapacity(1000);
        threadPoolTaskExecutor.setKeepAliveSeconds(60);
        threadPoolTaskExecutor.initialize();
    }


    public static void main(String[] args) {
        /**
         * anyOf() 有一个返回即可
         */
        CompletableFuture<String> completableFuture1 = CompletableFuture.supplyAsync(() -> {
            return "Hello";
        }, threadPoolTaskExecutor);
        CompletableFuture<String> completableFuture2 = CompletableFuture.supplyAsync(() -> {
            return "World";
        }, threadPoolTaskExecutor);

        CompletableFuture<Object> result = CompletableFuture.anyOf(completableFuture1,
                completableFuture2);
        logger.info("result:{}", result.join());
        
        threadPoolTaskExecutor.shutdown();
    }

}

12、allOf() 全部执行完

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.CompletableFuture;

public class CompletableFutureDemo {
    private static Logger logger = LoggerFactory.getLogger(CompletableFutureDemo.class);
    private static ThreadPoolTaskExecutor threadPoolTaskExecutor;

    static {
        threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
        threadPoolTaskExecutor.setCorePoolSize(10);
        threadPoolTaskExecutor.setMaxPoolSize(10);
        threadPoolTaskExecutor.setThreadNamePrefix("CompletableFutureDemo-");
        threadPoolTaskExecutor.setQueueCapacity(1000);
        threadPoolTaskExecutor.setKeepAliveSeconds(60);
        threadPoolTaskExecutor.initialize();
    }


    public static void main(String[] args) {
        /**
         * allOf() 全部执行完
         */
        CompletableFuture<String> completableFuture1 = CompletableFuture.supplyAsync(() -> {
            return "Hello";
        }, threadPoolTaskExecutor);
        CompletableFuture<String> completableFuture2 = CompletableFuture.supplyAsync(() -> {
            return "World";
        }, threadPoolTaskExecutor);

        CompletableFuture<Void> voidCompletableFuture = CompletableFuture.allOf(completableFuture1, completableFuture2);
        logger.info("completableFuture1:{},completableFuture2:{}",completableFuture1.isDone(),completableFuture2.isDone());

        threadPoolTaskExecutor.shutdown();
    }

}
啥也不会、啥也不是
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Future&CompletableFuture
Learning_foolish的博客
04-05 372
Future&FutureTask介绍
FutureTask原理和CompletableFuture使用
weixin_46919552的博客
07-25 362
FutureTask原理和CompletableFuture使用
【Java并发编程实战】（十七）：Future和CompletableFuture的原理及实战——异步编程没有那么难
少侠露飞的学习笔记
04-21 965
Future及CompletableFuture的原理及实战
Future和CompletableFuture详解
weixin_45948019的博客
02-10 742
CompletableFuture有且只有一个构造方法，这个构造方法的注解表示创造一个新的不完整的CompletableFuture，所以当我们需要用到CompletableFuture的时候，不要用new来创建。Future接口（FutureTask实现类）定义了操作异步任务执行的一些方法，如获取异步任务执行结果、取消任务的执行、判断任务是否被取消、判断任务执行是否完毕等。如果想将多个异步任务的计算结果组合起来，后一个异步任务的计算结果需要前一个异步任务的值。对比串行执行，效率还是有很大的提升。
java中Future使用详细介绍
最新发布
weixin_43950588的博客
05-28 424
java中Future使用详细介绍
【并发编程学习篇】Future&CompletableFuture的使用与原理剖析
一个勤勤恳恳的程序猿
03-17 5680
当需要批量提交异步任务的时候建议你使用CompletionServiceCompletionService将线程池Executor和阻塞队列BlockingQueue的功能融合在了一起，能够让批量异步任务的管理更简单。CompletionService能够让异步任务的执行结果「有序化」先执行完的先进入阻塞队列，利用这个特性，你可以轻松实现后续处理的有序性，避免无谓的等待，同时还可以快速实现诸如Forking Cluster这样的需求。线程池隔离。
Future和CompletableFuture的区别和对比，以及Future主要的四个缺点——不能回调会阻塞、批量任务处理彼此依赖会阻塞、不能多个任务级联执行、得不到最先完成的任务
走过路过不要错过
05-27 8161
1. Future在执行结束后没法回调，调用get方法会被阻塞；CompletableFuture调用get方法获取结果也会被阻塞。 2.但是CompletableFuture可以回调，可不通过get方法获取结果。 3. Future模式执行批量任务，需要遍历Future列表依次获取结果，如果某个任务执行时间很长，那么会阻塞列表其它任务。 4. CompletableFuture模式通过回调可以得到执行结果，不会阻塞其它任务。 ...
CompletableFuture 和 Future 的区别
weixin_42051691的博客
08-14 829
CompletableFuture 和 Future的区别
在Spring Boot2中使用CompletableFuture的方法教程
08-26
本文将深入探讨如何在Spring Boot 2中有效地使用`CompletableFuture`。 首先，`@Async`注解允许我们标记一个方法为异步执行，这意味着该方法将在单独的线程中运行，而非阻塞当前的执行流程。为了启用这个特性，我们...
Java8 CompletableFuture详解
09-04
Java 8 的 `CompletableFuture` 是对传统 `Future` 接口的重要扩展，它引入了丰富的功能，使得异步编程和事件驱动模型更加便捷。`CompletableFuture` 不仅集成了 Guava 的 `ListenableFuture` 和 `SettableFuture` ...
CompletableFuture
01-22
Future 接口仅提供了 get() 和 isDone 这样的简单方法，仅凭 Future 无法为 CompletableFuture 提供丰富的能力。那么，CompletableFuture 又是如何扩展自己的能力的呢？这就不得不说 CompletionStage 接口了，它是 ...
tcpasyncclient:使用 AsynchronousSocketChannel 和 CompletableFuture 的简单 TCP 客户端
07-16
本文将深入探讨如何使用`AsynchronousSocketChannel`和`CompletableFuture`来创建一个高效的TCP客户端。`AsynchronousSocketChannel`是Java NIO（非阻塞I/O）的一部分，提供了一种异步的socket通信方式，而`...
Spring Boot对Future模式的支持详解
08-26
Spring Boot对Future模式的支持使得开发者可以更方便地在应用程序中实现异步处理，从而提高系统的并发性能和响应速度。在实际开发中，当遇到需要执行耗时操作或复杂计算时，我们可以利用多线程来提升效率，而Future...
Java并发编程系列一：Future和CompletableFuture解析与使用
weixin_30912051的博客
08-12 1119
一、Future模式 Java 1.5开始，提供了Callable和Future，通过它们可以在任务执行完毕之后得到任务执行结果。 Future接口可以构建异步应用，是多线程开发中常见的设计模式。 当我们需要调用一个函数方法时。如果这个函数执行很慢,那么我们就要进行等待。但有时候,我们可能并不急着要结果。 因此,我们可以让被调用者立即返回,让他在后台慢慢处理这个请求。对于调用者来说,则可以...
Java CompletableFuture.allOf() 、thenApplyAsync()、thenRun()等使用
HSJ0170的博客
05-07 3533
package java8; //import com.google.common.util.concurrent.ThreadFactoryBuilder; import java.time.Instant; import java.time.temporal.ChronoUnit; import java.util.ArrayList; import java.util.List; import java.util.Random; import java.util.concurrent.*; im
java多线程之FutureTask、Future、CompletableFuture
程序三两行
07-18 2849
FutureTask除了实现Future接口外，还实现了Runnable接口。因此，FutureTask可以交给 Executor执行，也可以由调用线程直接执行（FutureTask.run()）。
Future与CompletableFuture
任天柳
08-09 1063
Future与CompletableFuture的比较与使用
【异步编程学习笔记】JDK中的FutureTask和CompletableFuture详解（使用示例、源码）
qq_41358574的博客
09-28 1226
FutureTask概述 FutureTask代表了一个可被取消的异步计算任务，该类实现了Future接口，比如提供了启动和取消任务、查询任务是否完成、获取计算结果的接口。 FutureTask任务的结果只有当任务完成后才能获取，并且只能通过get系列方法获取，当结果还没出来时，线程调用get系列方法会被阻塞。另外，一旦任务被执行完成，任务将不能重启，除非运行时使用了runAndReset方法。FutureTask中的任务可以是Callable类型，也可以是Runnable类型（因为FutureTask实现
CompletableFuture——whenComplete与handle、thenApply与thenCompose的区别
DawdleD的博客
02-20 6725
CompletableFuture类提供了使用函数式编程风格来编排异步处理逻辑的方案。 本文将探讨标题所述的几个方法在使用场景方面的区别。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值