FutureTask获取多线程处理结果

package com.test.ThreadPoolExecutor;


import com.alibaba.fastjson.JSON;

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

public class FutureThreadCase {

    public static void main(String[] args){
        List<Integer> prehandlerList = new ArrayList<>();
        FutureThreadCase futureThreadCase = new FutureThreadCase();
        for(int i = 1; i <= 10; i++){
            prehandlerList.add(i);
        }
        ExecutorService executor = Executors.newFixedThreadPool(3);
        List<FutureTask<String>> futureList = new ArrayList<>();
        for(Integer handler: prehandlerList){
            FutureTask<String> futureTask = new FutureTask<>(() -> futureThreadCase.deal(handler));
            executor.submit(futureTask);
            futureList.add(futureTask);
        }
        executor.shutdown();

        List<String> finalResult = new ArrayList<>();
        for(FutureTask<String> dealResult: futureList){
            boolean isCancelled = false;
            Future<String> future = dealResult;
            if(!isCancelled){
                try {
                    String result = future.get(5000, TimeUnit.MILLISECONDS);
                    finalResult.add(result);
                }catch (Exception e){
                    System.out.println(e);
                }
            }
        }
        System.out.println("多线程处理完毕.");

        System.out.println("多线程处理结果为:");
        System.out.println(JSON.toJSONString(finalResult));
    }

    private String deal(Integer handler){
        if(handler != null){
            System.out.println("单个线程处理开始:"+handler);
            String str = String.valueOf(handler);
            try{
                Thread.sleep(2000);
            }catch (Exception e){ }
            System.out.println("单个线程处理完毕:"+handler);
            return str;
        }
        return null;
    }
}

可以发现FutureTask是等待所有线程都处理完毕之之后才会继续进行后面的处理，而Future也可以设置超时时间来控制线程处理的时间。

 

以上的方法在JDK1.8之后就效率就比不上CompletableFuture了，以下是CompletableFuture多线程处理结果的方法：

import com.alibaba.fastjson.JSON;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Vector;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CompletableFutureCase {

    public static final ExecutorService executor = Executors.newFixedThreadPool(3);

    public static void main(String[] args) {
        List<String> requestList = new ArrayList<>(Arrays.asList("5,10,20,30,50,80,100,130,250".split(",")));
        Vector<Integer> dealResult = new Vector<>();
        try{
            CompletableFuture[] cfs = requestList.stream().map(i ->
                    CompletableFuture.supplyAsync(() -> doubleCalc(i), executor)
                    .whenComplete((v, e) -> {
                        dealResult.add(v);
                    }
            )).toArray(CompletableFuture[]::new);
            CompletableFuture.allOf(cfs).join();
            System.out.println(JSON.toJSONString(dealResult));
        } catch (Exception e){
            e.printStackTrace();
        }
    }

    private static Integer doubleCalc(String num){
        try{
            System.out.println(Thread.currentThread().getName() + " 正在处理 " + num);
            Thread.sleep(2000);
            return Integer.parseInt(num) * 2;
        } catch (Exception e){
            e.printStackTrace();
        }
        return 0;
    }
}