Java多线程异步编程之：Futrue、FutureTask、CompletionService、CompletableFuture

最新推荐文章于 2022-07-25 17:55:47 发布
最新推荐文章于 2022-07-25 17:55:47 发布
阅读量607 收藏 1
点赞数
分类专栏： java 文章标签： java 多线程 并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HSJ0170/article/details/121395136
版权

代码：https://gitee.com/hsjjsh123/multi-thread.git

上结论：
在这里插入图片描述
demo为先，上代码：

一、Futrue：

package com.hsj.future;

import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * @author denny.zhang
 * @author HeShengjin 2356899074@qq.com
 * @ClassName: FutureDemo
 * @Description: Future多线程并发任务结果归集
 * @date 2016年11月4日 下午1:50:32
 */
public class FutureDemo {

    public static void main(String[] args) {
        Long start = System.currentTimeMillis();
        //开启多线程
        ExecutorService exs = Executors.newFixedThreadPool(10);
        try {
            //结果集
            List<Integer> list = new ArrayList<Integer>();
            List<Future<Integer>> futureList = new ArrayList<Future<Integer>>();
            //1.高速提交10个任务，每个任务返回一个Future入list
            for (int i = 0; i < 10; i++) {
                futureList.add(exs.submit(new CallableTask(i + 1)));
            }
            Long getResultStart = System.currentTimeMillis();
            System.out.println("结果归集开始时间=" + new Date());
            //2.结果归集，用迭代器遍历futureList,高速轮询（模拟实现了并发），任务完成就移除
            while (futureList.size() > 0) {
                Iterator<Future<Integer>> iterable = futureList.iterator();
                //遍历一遍
                while (iterable.hasNext()) {
                    Future<Integer> future = iterable.next();
                    //如果任务完成取结果，否则判断下一个任务是否完成
//                    if (future.isDone() && !future.isCancelled()){//非阻塞
                    //获取结果
                    Integer i = future.get();//阻塞
                    System.out.println("任务i=" + i + "获取完成，移出任务队列！" + new Date());
                    list.add(i);
                    //任务完成移除任务
                    iterable.remove();
//                    }else{
//                        Thread.sleep(1);//避免CPU高速运转，这里休息1毫秒，CPU纳秒级别
//                    }
                }
            }
            System.out.println("list=" + list);
            System.out.println("总耗时=" + (System.currentTimeMillis() - start) + ",取结果归集耗时=" + (System.currentTimeMillis() - getResultStart));
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            exs.shutdown();
        }
    }
}

package com.hsj.future;

import java.util.Date;
import java.util.concurrent.Callable;

public class CallableTask implements Callable<Integer> {
    Integer i;

    public CallableTask(Integer i) {
        super();
        this.i = i;
    }

    @Override
    public Integer call() throws Exception {
        if (i == 1) {
            Thread.sleep(3000);//任务1耗时3秒
        } else if (i == 5) {
            Thread.sleep(5000);//任务5耗时5秒
        } else {
            Thread.sleep(1000);//其它任务耗时1秒
        }
        System.out.println("task线程：" + Thread.currentThread().getName() + "任务i=" + i + ",完成！"+ new Date());
        return i;
    }
}

二、FutureTask：

package com.hsj.futuretask;

import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

/**
 *
 * @ClassName:FutureTaskDemo
 * @Description:FutureTask实现多线程并发执行任务并取结果归集
 *              有点儿类似于Promise方式
 * @author diandian.zhang
 * @author HeShengjin 2356899074@qq.com
 * @date 2017年6月16日上午10:36:05
 */
public class FutureTaskDemo {

    public static void main(String[] args)  {
        Long start = System.currentTimeMillis();
        //开启多线程
        ExecutorService exs = Executors.newFixedThreadPool(10);
        try {
            //结果集
            List<Integer> list = new ArrayList<Integer>();
            List<FutureTask<Integer>> futureList = new ArrayList<FutureTask<Integer>>();
            //启动线程池，10个任务固定线程数为5
            for(int i=0;i<10;i++){
                FutureTask<Integer> futureTask = new FutureTask<Integer>(new CallableTask(i+1));
                //提交任务，添加返回，Runnable特性
                exs.submit(futureTask);
                //Future特性
                futureList.add(futureTask);
            }
            Long getResultStart = System.currentTimeMillis();
            System.out.println("结果归集开始时间="+new Date());
            //结果归集
            while(futureList.size()>0){
                Iterator<FutureTask<Integer>> iterable = futureList.iterator();
                //遍历一遍
                while(iterable.hasNext()){
                    Future<Integer> future = iterable.next();
//                    if (future.isDone()&& !future.isCancelled()) {//非阻塞
                        //Future特性
                        Integer i = future.get();//阻塞
                        System.out.println("任务i=" + i + "获取完成，移出任务队列！" + new Date());
                        list.add(i);
                        //任务完成移除任务
                        iterable.remove();
//                    }else {
//                        //避免CPU高速轮循，可以休息一下。
//                        Thread.sleep(1);
//                    }
                }
            }

            System.out.println("list="+list);
            System.out.println("总耗时="+(System.currentTimeMillis()-start)+",取结果归集耗时="+(System.currentTimeMillis()-getResultStart));
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            exs.shutdown();
        }
    }

}


package com.hsj.futuretask;

import java.util.Date;
import java.util.concurrent.Callable;

/**
 * @Description 回调方法
 * @author denny
 * @author HeShengjin 2356899074@qq.com
 * @date 2018/8/17 下午3:16
 */
public class CallableTask implements Callable<Integer> {
    Integer i;

    public CallableTask(Integer i) {
        super();
        this.i = i;
    }

    @Override
    public Integer call() throws Exception {
        if (i == 1) {
            Thread.sleep(3000);//任务1耗时3秒
        } else if (i == 5) {
            Thread.sleep(5000);//任务5耗时5秒
        } else {
            Thread.sleep(1000);//其它任务耗时1秒
        }
        System.out.println("task线程：" + Thread.currentThread().getName() + "任务i=" + i + ",完成！"+ new Date());
        return i;
    }
}

三、CompletionService：

package com.hsj.completionservice;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 *
 * @ClassName: CompletionServiceDemo
 * @Description: CompletionService多线程并发任务结果归集
 * @author denny.zhang
 * @author HeShengjin 2356899074@qq.com
 * @date 2016年11月4日 下午1:50:32
 *
 */
public class CompletionServiceDemo{

    public static void main(String[] args)  {
        Long start = System.currentTimeMillis();
        //开启多线程
        ExecutorService exs = Executors.newFixedThreadPool(10);
        try {
            int taskCount = 10;
            //结果集
            List<Integer> list = new ArrayList<Integer>();
            //1.定义CompletionService
            CompletionService<Integer> completionService = new ExecutorCompletionService<Integer>(exs);
            List<Future<Integer>> futureList = new ArrayList<Future<Integer>>();
            //2.添加任务
            for(int i=0;i<taskCount;i++){
                futureList.add(completionService.submit(new Task(i+1)));
            }
            //==================结果归集===================
            //方法1：future是提交时返回的，遍历queue则按照[任务提交顺序]，获取结果
            for (Future<Integer> future : futureList) {
                System.out.println("====================");
                Integer result = future.get();//线程在这里阻塞等待该任务执行完毕,按照
                System.out.println("任务result="+result+"获取到结果!"+new Date());
                list.add(result);
            }

//            //方法2.使用内部阻塞队列的take()
//            for(int i=0;i<taskCount;i++){
//                Integer result = completionService.take().get();//采用completionService.take()，内部维护阻塞队列，[任务先完成的先获取到]
//                System.out.println("任务i=="+result+"完成!"+new Date());
//                list.add(result);
//            }
            System.out.println("list="+list);
            System.out.println("总耗时="+(System.currentTimeMillis()-start));
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            exs.shutdown();//关闭线程池
        }

    }

}


package com.hsj.completionservice;

import java.util.concurrent.Callable;

public class Task implements Callable<Integer> {
    Integer i;

    public Task(Integer i) {
        super();
        this.i=i;
    }

    @Override
    public Integer call() throws Exception {
        if(i==5){
            Thread.sleep(5000);
        }else{
            Thread.sleep(1000);
        }
        System.out.println("线程："+Thread.currentThread().getName()+"任务i="+i+",执行完成！");
        return i;
    }

}

四、CompletableFuture：

package com.hsj.completablefuture;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


/**
 *
 * @ClassName:CompletableFutureDemo
 * @Description:多线程并发任务,取结果归集
 * @author diandian.zhang
 * @author HeShengjin 2356899074@qq.com
 * @date 2017年6月14日下午12:44:01
 */
public class CompletableFutureDemo {
    public static void main(String[] args) {
        Long start = System.currentTimeMillis();
        //结果集
        List<String> list = new ArrayList<String>();
        //定长10线程池
        ExecutorService exs = Executors.newFixedThreadPool(10);
        List<CompletableFuture<String>> futureList = new ArrayList<>();
        //任务
        final List<Integer> taskList = new ArrayList(){{
            add(2); add(1); add(3); add(6); add(4); add(5); add(8); add(9); add(7); add(10);
        }};
        try {

//            方式一：全流式处理转换成CompletableFuture[]+组装成一个无返回值CompletableFuture，join等待执行完毕。返回结果whenComplete获取
            CompletableFuture[] cfHaveBack = taskList
                    .stream()
                    .map(
                            object-> CompletableFuture.supplyAsync(()->calc(object), exs)
                                    .thenApply(integer->Integer.toString(integer))//中间的转换
                                    //如需获取任务完成先后顺序，此处代码即可
                                    .whenComplete((v, e) -> {
                                        System.out.println("任务"+v+"完成!result="+v+"，异常 e="+e+","+new Date());
                                        list.add(v);
                                    })
                    ).toArray(CompletableFuture[]::new);
            //等待总任务完成，但是封装后无返回值，必须自己whenComplete()获取
            CompletableFuture.allOf(cfHaveBack).join();
            System.out.println("任务完成，结果list="+list+"；耗时="+(System.currentTimeMillis()-start));

            //华丽丽的分割线
            System.out.println("///");

            //方式二：全流式处理转换成CompletableFuture[]+组装成一个无返回值CompletableFuture，join等待执行完毕。无返回值。
            CompletableFuture[] cfNoBack = taskList
                    .stream()
                    .map(
                            object-> CompletableFuture.runAsync(
                                    ()->calcV2(taskList,object),
                                    exs)
                    ).toArray(CompletableFuture[]::new);
            //等待总任务完成，但是封装后无返回值，必须自己whenComplete()获取
            CompletableFuture.allOf(cfNoBack).join();
            System.out.println("任务完成，结果taskList="+taskList+"；耗时="+(System.currentTimeMillis()-start));
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            exs.shutdown();
        }
    }

    /**
     * @Description:有返回值
     * @author HeShengjin 2356899074@qq.com
     * @date 2021/11/18 10:21
     */
    public static Integer calc(Integer i){
        try {
            if(i==1){
                //任务1耗时3秒
                Thread.sleep(3000);
            }else if(i==5){
                //任务5耗时5秒
                Thread.sleep(5000);
            }else{
                //其它任务耗时1秒
                Thread.sleep(1000);
            }
            System.out.println("task线程："+Thread.currentThread().getName()+"任务i="+i+",完成！+"+new Date());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return i;
    }
    /**
     * @Description:没有返回值
     * @author HeShengjin 2356899074@qq.com
     * @date 2021/11/18 10:21
     */
    public static void calcV2(List<Integer> taskList,Integer i){
        try {
            if(i==1){
                //任务1耗时3秒
                Thread.sleep(3000);
            }else if(i==5){
                //任务5耗时5秒
                Thread.sleep(5000);
            }else{
                //其它任务耗时1秒
                Thread.sleep(1000);
            }
            //自己的业务逻辑
            System.out.println("task线程："+Thread.currentThread().getName()+"任务i="+i+",完成！+"+new Date());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

感谢：多线程并发执行任务，取结果归集。终极总结：Future、FutureTask、CompletionService、CompletableFuture

南下狩猎的小花猫
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA Future类详解
bobozai86的博客
04-05 3万+
1. Future的应用场景 在并发编程中，我们经常用到非阻塞的模型，在之前的多线程的三种实现中，不管是继承thread类还是实现runnable接口，都无法保证获取到之前的执行结果。通过实现Callback接口，并用Future可以来接收多线程的执行结果。 Future表示一个可能还没有完成的异步任务的结果，针对这个结果可以添加Callback以便在任务执行成功或失败后作出相应的操作。 举个例子：比如去吃早点时，点了包子和凉菜，包子需要等3分钟，凉菜只需1分钟，如果...
Java Futrue模式简单例子和使用场景
入门菜鸟程序员的成长
09-23 522
之前看视频上别人讲解java的Futrue功能可以提高系统运行效率，之后有一点疑惑，通过一个简单的例子了解Futrue到底好处在哪。 例子很简单，通过一个线程池来让子线程去执行任务，主线程打印一句话后调用futrue的get()方法。 import org.junit.Test; import org.junit.runner.RunWith; import org.springframew...
Java中的Future
tugangkai的专栏
12-27 8058
1.Future解决了什么问题 Future是java中的一个接口，主要用于java多线程计算过程的异步结果获取，能够感知计算的进度，与传统的多线程实现方式，比如继承Thread类，实现runnable接口，它们主要的局限在于对多线程运行的本身缺少监督。 2.Callable接口和Runnable接口区别 下面是它们之间的主要区别: runable接口是用run方法作为线程运行任务的入口，cal...
Java并发编程---Futrue模式
汉南最後の読書人
01-05 467
一.Futrue模式概念      Futrue模式有点类似于商品订单.比如在网购时,当看中某件商品时,就可以提交订单,当订单处理完成后,在家里等待商品送货上门即可.或者更形象地,我们发送Ajax请求的时候,页面是异步地进行后台处理,用户无须一直等待请求的结果,可以继续浏览或操作其他内容.                     二.代码示例 package com.threa
线程池——futuretask、CompletionService、CompletableFuture
m0_46598535的博客
06-25 1985
java
Flutter 假异步的实现示例
01-04
Flutter 也有自己的消息队列，只不过队列直接封装在了 Dart 的线程类型 Isolate 里面了，不过 Flutter 还是提供了 Futrue 这个 API 来专门来操作各种消息，以及实现基于消息队列的假异步 Flutter 的“异步”机制 ...
Asterisk：The Futrue of Telephony
07-01
Asterisk：The Futrue of Telephony 是一本详细介绍Asterisk技术的很好的参考书，全英文，原汁原味，参考和使用价值极高。
Future两个简单易懂的DEMO
04-29
Future两个简单易懂的DEMO，代码完整，对接口进行简单的介绍和使用。
getabstract the book of "the future of almost everything"
09-30
abstract reading of the book - the future of almost everything, worth to read it.
Future获取子线程的执行结果
法毅的博客
06-19 4625
1. Runnable的缺陷 2.Callable 接口 3. Future 类 4.用法1: 线程池的submit方法会回Future对象，6分da
Java高并发（七）——Future模式
学会改变自己——才能突破
12-09 5396
       大家想下，多线程处理提高性能的根本本质在哪？其实就是将串行的处理步骤进行并行的处理，其实总时间是没有缩短的。也就是以前一个人干活需要10个小时，而十个人干同样的活需要1小时，从而缩短处理时间。但是如果干活有先后限制怎么办？例如工作中：测试前必须编码，编码前必须设计，设计前必须需求分析，分析前……如何提高这种情况的性能呢？或者说是如何让这中情况下的线程更加充分利用呢？Future模式—...
多线程并发执行任务，取结果归集。终极总结：Future、FutureTask、CompletionService、CompletableFuture
zdy0_2004的专栏
06-20 8683
http://www.cnblogs.com/dennyzhangdd/p/7010972.html 目录 1.Futrue 2.FutureTask 3.CompletionService 4.CompletableFuture 5.总结 ================正文分割线================= 开启线程执行
【异步编程学习笔记】JDK中的FutureTask和CompletableFuture详解（使用示例、源码）
qq_41358574的博客
09-28 1197
FutureTask概述 FutureTask代表了一个可被取消的异步计算任务，该类实现了Future接口，比如提供了启动和取消任务、查询任务是否完成、获取计算结果的接口。 FutureTask任务的结果只有当任务完成后才能获取，并且只能通过get系列方法获取，当结果还没出来时，线程调用get系列方法会被阻塞。另外，一旦任务被执行完成，任务将不能重启，除非运行时使用了runAndReset方法。FutureTask中的任务可以是Callable类型，也可以是Runnable类型（因为FutureTask实现
并发编程 - Future、FutureTask、CompletableFuture
The Secret
09-28 372
本文分析并发编程的异步计算的Future、FutureTask、CompletableFuture。
Java多线程编程（三）-Future、FutureTask、CompletableFuture
qq_41786692的博客
07-08 4666
一、Future模式1.Future简介    Future本身是一种被广泛运用的开发设计模式，在很大程度上简化需要数据流同步的并发应用开发。Future对象本身可以看做是一个显示的引用，他的核心思想是异步调用，类似于ajax的异步请求，无需等待请求的结果，可以继续去处理其他的业务。    例如就像现在在网上买东西，选中东西付款之后，不会立即拿到东西，而是拿到一个买东西的订单号，然后过一段时间之后...
Java多线程(十): FutureTask CompletableFuture详解
Java Spring Elasticsearch
02-14 2341
Java多线程:FutureTask CompletableFuture1. Runnable与Callable2. Future接口和FutureTask3. ExecutorService几种线程池4. 使用Callable+FutureTask获取执行结果5. CompletableFuture5.1 CompletableFuture中4个异步执行任务静态方法5.2 组合方法 1. Run...
JUC并发编程（十五）-异步回调:Futrue 的实现类CompletableFuture
二总的猫
02-26 570
15、异步回调:Futrue 的实现类CompletableFuture 概述 Futrue 设计初衷： 对将来会发生的结果进行建模~ 程序的性能要高，要异步处理！同步并阻塞！ A 线程做完了返回一个结果告诉main我做完了！ Futrue就相当于ajax。 实例：CompletableFuture无返回结果情况测试 package com.interview.concurrent....
FutureTask原理和CompletableFuture使用
weixin_46919552的博客
07-25 353
FutureTask原理和CompletableFuture使用
CompletableFuture的使用介绍, CompletableFuture与FutureTask的区别
你走过的路 风都是暖的
07-31 1610
CompletableFuture实现了CompletionStage接口和Future接口，前者是对后者的一个扩展，增加了异步回调、流式处理、多个Future组合处理的能力，使Java在处理多任务的协同工作时更加顺畅便利。 总的来说简洁了FutureTask与线程池的配合使用 没啥太大区别吧我觉得, 使用方法不一样, 多了一些方法... futureTask 创建异步任务 FutureTask<String> str...
completablefuture和futrue
最新发布
04-11
CompletableFuture和Future是Java中用于异步处理的两种不同的机制。Future是Java5加入的，可以异步地执行代码，并且在后台完成任务后返回结果。但Future有一个限制，那就是一旦调用get()方法获取结果之后，程序会...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值