多线程并发执行任务，取结果归集：Future、FutureTask、CompletionService、CompletableFuture

最新推荐文章于 2024-09-17 17:03:09 发布
最新推荐文章于 2024-09-17 17:03:09 发布
阅读量3.1k 收藏 6
点赞数 3
分类专栏： java

Future

(1)cancle

(2)get

(3)isCancle

(4)isDone

示例：

使用线程池提交Callable接口任务，返回Future接口，添加进李斯特，最后遍历FutureList且内部使用while轮询，并发获取结果

package thread.future;

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

/**
 * 
 * @ClassName: FutureDemo
 * @Description: Future多线程并发任务结果归集
 * @author denny.zhang
 * @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,高速轮询（模拟实现了并发）获取future状态成功完成后获取结果，退出当前循环
            for (Future<Integer> future : futureList) {
                while (true) {//CPU高速轮询：每个future都并发轮循，判断完成状态然后获取结果，这一行，是本实现方案的精髓所在。即有10个future在高速轮询，完成一个future的获取结果，就关闭一个轮询
                    if (future.isDone()&& !future.isCancelled()) {//获取future成功完成状态，如果想要限制每个任务的超时时间，取消本行的状态判断+future.get(1000*1, TimeUnit.MILLISECONDS)+catch超时异常使用即可。
                        Integer i = future.get();//获取结果
                        System.out.println("任务i="+i+"获取完成!"+new Date());
                        list.add(i);
                        break;//当前future获取结果完毕，跳出while
                    } else {
                        Thread.sleep(1);//每次轮询休息1毫秒（CPU纳秒级），避免CPU高速轮循耗空CPU---》新手别忘记这个
                    }
                }
            }
            System.out.println("list="+list);
            System.out.println("总耗时="+(System.currentTimeMillis()-start)+",取结果归集耗时="+(System.currentTimeMillis()-getResultStart));
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            exs.shutdown();
        }
    }
    static 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+",完成！");  
            return i;
        }
    }
}

FutureTask

1.Runnable接口，可开启单个线程执行。

2.Future<v>接口，可接受Callable接口的返回值，futureTask.get阻塞获取结果。

/**
 * 
 * @ClassName:FutureTaskDemo
 * @Description:FutureTask弥补了Future必须用线程池提交返回Future的缺陷，实现功能如下：
 * 1.Runnable接口，可开启线程执行。
 * 2.Future<v>接口，可接受Callable接口的返回值，futureTask.get()阻塞获取结果。
 * 这两个步骤：一个开启线程执行任务，一个阻塞等待执行结果，分离这两步骤，可在这两步中间穿插别的相关业务逻辑。
 * @author diandian.zhang
 * @date 2017年6月16日上午10:36:05
 */
public class FutureTaskContorlDemo {
    
    public static void main(String[] args)  {
        try {
            System.out.println("=====例如一个统计公司总部和分部的总利润是否达标100万==========");
            //利润
            Integer count = 0;
            //1.定义一个futureTask，假设去远程http获取各个分公司业绩.
            FutureTask<Integer> futureTask = new FutureTask<Integer>(new CallableTask());
            Thread futureTaskThread =  new Thread(futureTask);
            futureTaskThread.start();
            System.out.println("futureTaskThread start！"+new Date());
            
            //2.主线程先做点别的事
            System.out.println("主线程查询总部公司利润开始时间："+new Date());
            Thread.sleep(5000);
            count+=10;//北京集团总部利润。
            System.out.println("主线程查询总部公司利润结果时间："+new Date());
            
            //总部已达标100万利润，就不再继续执行获取分公司业绩任务了
            if(count>=100){
                System.out.println("总部公司利润达标，取消futureTask！"+new Date());
                futureTask.cancel(true);//不需要再去获取结果，那么直接取消即可
            }else{
                System.out.println("总部公司利润未达标，进入阻塞查询分公司利润！"+new Date());
                //3总部未达标.阻塞获取，各个分公司结果
                Integer i = futureTask.get();//真正执行CallableTask
                System.out.println("i="+i+"获取到结果!"+new Date()+new Date());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 
     * @ClassName:CallableTask
     * @Description:一个十分耗时的任务
     * @author diandian.zhang
     * @date 2017年6月16日上午10:39:04
     */
    static class CallableTask implements Callable<Integer>{
        @Override
        public Integer call() throws Exception {
            System.out.println("CallableTask-call，查询分公司利润，执行开始！"+new Date());
            Thread.sleep(10000);
            System.out.println("CallableTask-call，查询分公司利润，执行完毕！"+new Date());
            return 10;
        }
    }
package thread.future;

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

/**
 * 
 * @ClassName:FutureTaskDemo
 * @Description:FutureTask实现多线程并发执行任务并取结果归集
 * @author diandian.zhang
 * @date 2017年6月16日上午10:36:05
 */
public class FutureTaskDemo {
    
    public static void main(String[] args)  {
        Long start = System.currentTimeMillis();
        //开启多线程
        ExecutorService exs = Executors.newFixedThreadPool(5);
        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));
                //提交任务，添加返回
                exs.submit(futureTask);//Runnable特性
                futureList.add(futureTask);//Future特性
            }
            Long getResultStart = System.currentTimeMillis();
            System.out.println("结果归集开始时间="+new Date());
            //结果归集
            for (FutureTask<Integer> future : futureList) {
                while (true) {
                    if (future.isDone()&& !future.isCancelled()) {
                        Integer i = future.get();//Future特性
                        System.out.println("i="+i+"获取到结果!"+new Date());
                        list.add(i);
                        break;
                    }else {
                        Thread.sleep(1);//避免CPU高速轮循，可以休息一下。
                    }
                }
            }
            System.out.println("list="+list);
            System.out.println("总耗时="+(System.currentTimeMillis()-start)+",取结果归集耗时="+(System.currentTimeMillis()-getResultStart));
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            exs.shutdown();
        }
        
    }

    static 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("线程：["+Thread.currentThread().getName()+"]任务i="+i+",完成！"+new Date());  
            return i;

        }
        
    }

}

CompletionService

原因：内部通过阻塞队列+FutureTask，实现了任务先完成可优先获取到，即结果完成后顺序排序。

package thread.future;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.Callable;
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
 * @date 2016年11月4日 下午1:50:32
 *
 */
public class CompletionServiceDemo{

    public static void main(String[] args)  {
        Long start = System.currentTimeMillis();
        //开启3个线程
        ExecutorService exs = Executors.newFixedThreadPool(5);
        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();//关闭线程池
        }
        
    }

    static 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

JDK1.8才新加入的实现类，实现Future、CompletionStage两个接口。

package thread.future;

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;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import com.google.common.collect.Lists;

/**
 * 
 * @ClassName:CompletableFutureDemo
 * @Description:多线程并发任务,取结果归集
 * @author diandian.zhang
 * @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>();
        List<String> list2 = new ArrayList<String>();
        //定长10线程池
        ExecutorService exs = Executors.newFixedThreadPool(10);
        //List<CompletableFuture<String>> futureList = new ArrayList<>();
        List<Integer> taskList = Lists.newArrayList(2,1,3,4,5,6,7,8,9,10);
        try {
            //方式一：循环创建CompletableFuture list,调用sequence()组装返回一个有返回值的CompletableFuture，返回结果get()获取
//            for(int i=0;i<taskList.size();i++){
//                final int j=i+1;
//                CompletableFuture<String> future = CompletableFuture.supplyAsync(()->calc(j), exs)//异步执行
//                        .thenApply(e->Integer.toString(e))//Integer转换字符串    thenAccept只接受不返回不影响结果
                        .whenComplete((v, e) -> {//如需获取任务完成先手顺序，此处代码即可
                            System.out.println("任务"+v+"完成!result="+v+"，异常 e="+e+","+new Date());
                            list2.add(v);
                        })
//                        ;
//                futureList.add(future);
//            }
//            //流式获取结果
//            list = sequence(futureList).get();//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]此处不理解为什么是这样的顺序？谁知道求告知
            
            //方式二：全流式处理转换成CompletableFuture[]+组装成一个无返回值CompletableFuture，join等待执行完毕。返回结果whenComplete获取
            @SuppressWarnings("rawtypes")
            CompletableFuture[] cfs = taskList.stream().map(object-> CompletableFuture.supplyAsync(()->calc(object), exs)
                    .thenApply(h->Integer.toString(h))
                    .whenComplete((v, e) -> {//如需获取任务完成先手顺序，此处代码即可
                        System.out.println("任务"+v+"完成!result="+v+"，异常 e="+e+","+new Date());
                        list2.add(v);
                    }))
                    .toArray(CompletableFuture[]::new);
            CompletableFuture.allOf(cfs).join();//封装后无返回值，必须自己whenComplete()获取
            System.out.println("list2="+list2+"list="+list+",耗时="+(System.currentTimeMillis()-start));
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            exs.shutdown();
        }
    }
    
    public static Integer calc(Integer i){
        try {
            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());  
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return i;
    }
    
    /**
     * 
     * @Description 组合多个CompletableFuture为一个CompletableFuture,所有子任务全部完成，组合后的任务才会完成。带返回值，可直接get.
     * @param futures List
     * @return
     * @author diandian.zhang
     * @date 2017年6月19日下午3:01:09
     * @since JDK1.8
     */
    public static <T> CompletableFuture<List<T>> sequence(List<CompletableFuture<T>> futures) {
        //1.构造一个空CompletableFuture，子任务数为入参任务list size
        CompletableFuture<Void> allDoneFuture = CompletableFuture.allOf(futures.toArray(new CompletableFuture[futures.size()]));
        //2.流式（每个子任务join操作后转换为list）往空CompletableFuture中添加结果
        return allDoneFuture.thenApply(v -> futures.stream().map(CompletableFuture::join).collect(Collectors.<T>toList()));
    }
   
    /**
     * 
     * @Description Stream流式类型futures转换成一个CompletableFuture,所有子任务全部完成，组合后的任务才会完成。带返回值，可直接get.
     * @param futures Stream
     * @return
     * @author diandian.zhang
     * @date 2017年6月19日下午6:23:40
     * @since JDK1.8
     */
    public static <T> CompletableFuture<List<T>> sequence(Stream<CompletableFuture<T>> futures) {
        List<CompletableFuture<T>> futureList = futures.filter(f -> f != null).collect(Collectors.toList());
        return sequence(futureList);
    }
}

 

最后欢迎大家访问我的个人网站：1024s​​​​​​​

 

崔世勋
关注
专栏目录
【Java多线程】JUC之线程池(五) CompletionService 、CompletableFuture
墩墩分墩
03-10 1479
- 异步编程是编写`非阻塞的代码`，运行的任务`在一个单独的线程`，与`主线程隔离`，并且会`通知主线程它的进度`，`成功或者失败`。在这种方式中，`主线程不会被阻塞`，不需要一直等到子线程完成。`主线程可以并行的执行其他任务。`使用这种并行方式，可以极大的提高程序的性能。
并发编程 - Future、FutureTask、CompletableFuture
The Secret
09-28 450
本文分析并发编程的异步计算的Future、FutureTask、CompletableFuture。
多线程并发执行任务，取结果归集。终极总结：Future、FutureTask、CompletionService、CompletableFuture
zdy0_2004的专栏
06-20 8903
http://www.cnblogs.com/dennyzhangdd/p/7010972.html 目录 1.Futrue 2.FutureTask 3.CompletionService 4.CompletableFuture 5.总结 ================正文分割线================= 开启线程执行
设计模式之Future模式——提交任务后立即得到一个Future对象，后面利用该对象得到具体的执行结果。加上回调功能，任务执行结束通知调用者或直接回调相应方法
走过路过不要错过
05-26 296
1. Future模式的实现逻辑 1.1 在具体实现之前，我们先将Future模式的实现逻辑和流程理清楚，然后编写代码。 1.2 以甜品店买奶茶为例。第一步：得先有服务员；第二步：我们提交一个奶茶订单，会得到一张票据，由于制作奶茶花费时间较长，此时我们可以去买串串或者逛逛商场；第三步：服务员制作奶茶。 1.3 最后，我们回到甜品店，根据票据得到我们的奶茶。或者服务员没做好我们稍等一会。 1.4 从上面的分析可得，最主要的几个因素是：服务员、奶茶订单、票据。 2. Future模式的具体实现 .
线程池的使用:ExecutorService、CompletionService和CompletableFuture的区别
最新发布
minyunfei6的博客
09-17 1087
当我们需要处理批量任务的时候,经常会使用线程池来提高处理速度,但线程池的使用方式有多种,今天主要来介绍一下ExecutorService、CompletionService和CompletableFuture的区别。
CompletionService 和 CompletableFuture
weixin_39795049的博客
11-15 923
CompletionService 和 CompletableFuture
java多线程之对象的并发访问
热门推荐
sunpy
09-18 1万+
1.synchronized同步方法 --1.1方法内的变量是线程安全的 解释：由于方法内的变量是私有的，本体访问的同时别人访问不了，所以是线程安全的。 --1.2实例变量是非线程安全的 解释：由于实例变量可以由多个线程访问，当本体操作变量过程中，别人也可以抢占资源操作变量，使数据不同步了，所以是非线程安全的。（之前博文已经实现过这种情况） --1.3线程与锁 例： public
多线程并行执行，然后汇总结果
专注技术交流、咨询
01-18 1万+
代码下载地址：https://download.csdn.net/download/hekf2010/10926623 很多时间，需要多线程并行处理，然后汇总处理结果，例如，因为请参数数据量非常大，所以只能分批查询，然后将分批查询的结果汇总到一个数组中。 一、多线程类 import java.util.ArrayList; import java.util.List; import jav...
异步处理获取结果集异步接口Future
YoungLee16的博客
10-31 1385
Future接口是Concurrent包下的,关于他的解释,源码给的解释是 package java.util.concurrent; /** * A {@code Future} represents the result of an asynchronous * computation. Methods are provided to check if the computati...
多线程并发执行任务，取结果归集。终极总结：Future、FutureTask、CompletionService、CompletableFuture...
博客园搬家测试账号
04-10 1784
目录1.Futrue原理:demo:建议：此种方法可实现基本目标，任务并行且按照提交顺序获取结果。使用很普遍，老少皆宜，就是CPU有消耗，可以使用！2.FutureTask原理:demo:建议：demo1在特定场合例如有十分耗时的业务但有依赖于其他业务不一定非要执行的，可以尝试使用。demo2多线程并发执行并结果归集，这里多套一层FutureTask比较鸡肋（直接返回Future简单明了）不建议使...
Java多线程：Future、FutureTask与CompletableFuture及ThreadLocal解析
文档主要介绍了Future、FutureTask和CompletableFuture这三个与Java多线程返回对象相关的概念，以及ThreadLocal在资源独享线程中的应用。" 在Java多线程编程中，处理线程的返回值是一项挑战。通常，直接使用`...
Java多线程编程（三）-Future、FutureTask、CompletableFuture
qq_41786692的博客
07-08 4800
一、Future模式1.Future简介    Future本身是一种被广泛运用的开发设计模式，在很大程度上简化需要数据流同步的并发应用开发。Future对象本身可以看做是一个显示的引用，他的核心思想是异步调用，类似于ajax的异步请求，无需等待请求的结果，可以继续去处理其他的业务。    例如就像现在在网上买东西，选中东西付款之后，不会立即拿到东西，而是拿到一个买东西的订单号，然后过一段时间之后...
【多线程】获取多线程执行结果
sui_feng_piao_guo的博客
04-02 4609
1. 观察者模式结合多线程实现获取线程执行结果 在多线程开发中，我们没办法获取线程执行完成后的结果，但是当我们利用观察者模式的时候我们就可以获取到多线程的执行结果 2.具体实现 假设目前有一批id需要查询并需要获得查询结果， 利用多线程结合设计模式实现 2.1 LifeCycleListener public interface LifeCycleListener { void o...
java 多线程 结果汇总_java多线程细节归纳汇总
weixin_39842682的博客
02-24 634
1、前言一直以来，用过多线程，但是，在某些细节方面总是不注意，现特将一些基本知识点进行归纳汇总，以备后面的使用。2、Java多线程的实现方式JAVA多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。2.1继承Thread...
1000条数据开10个线程处理，每次处理50条CompletableFuture 实现
原&点、、
08-31 589
【代码】1000条数据开10个线程处理，每次处理50条CompletableFuture 实现。
线程池-批量获取多条线程的执行结果
不见其长，日有所长
02-25 3278
1. 前言 当向线程池提交callable任务后，我们可能需要一次性获取所有返回结果，有三种处理方法。 1.1 自己维护返回结果 // 创建一个线程池 ExecutorService executorService = Executors.newFixedThreadPool(10); // 存储执行结果的List List<Future<String>> results...
java future 线程,正确实现Java Future多线程
weixin_28804379的博客
02-20 456
In my servlet I am hitting several URL's to check their status and returning the response to user.Hitting multipe requests takes lot of time: need threads and timouts. But i need my threads to geturn ...
Future&CompletionService&CompletableFuture使用
csdn_halon的博客
08-15 396
Future&CompletionService&CompletableFuture使用
CompletableFuture多线程查询统一结果返回
qq_31674229的博客
09-19 1808
CompletableFuture多线程查询统一结果返回
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值