Callable结合CountDownLatch实战应用

一、需求场景描述

1.假设一个快递点有100万个快递要在一天送完，如果一个快递员送，可能要送100天。。。于是快递公司雇了100个快递员，这样送一天就可以把全部快递送完。

我们的线程池也是同样的思想，利用多个线程协作，并发的去执行任务。

二、流程图如下

 三、代码如下

import org.springframework.scheduling.concurrent.CustomizableThreadFactory;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.concurrent.*;

public class xxxxServiceImpl {

    private static ThreadPoolExecutor executor = new ThreadPoolExecutor(4, 4, 1,
            TimeUnit.MINUTES, new ArrayBlockingQueue<>(1000000),new CustomizableThreadFactory("thread-"),new ThreadPoolExecutor.AbortPolicy()
    );

    public static void demo(){
        //假设有20个数字 我们要输出到控制台
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20);
        //定义CountDownLatch的大小为list的长度
        final CountDownLatch latch = new CountDownLatch(list.size());

        List<Future<Map<String,Object>>> listResult=new ArrayList();
        List<Map<String, Object>> mapList = new ArrayList<>();

        //我们利用线程池去输出
        for(Integer number : list){
            CallableThreadPool callableThreadPool = new CallableThreadPool(number,latch);
            Future<Map<String,Object>> future = executor.submit(callableThreadPool);
            //将callable的返回值加入返回结果list
            listResult.add(future);
        }

        try {
            //等待所有任务都执行完之后再执行 即latch.count值为0
            latch.await();
            for(Object o:listResult){
                Future<Map<String,Object>> f1=(Future<Map<String, Object>>) o;
                mapList.add(f1.get());
            }
            //输出我们返回的结果
            for(Map<String, Object> map : mapList){
                for(Map.Entry<String, Object> entry: map.entrySet()){
                    System.out.print(entry.getKey());
                    System.out.print(entry.getValue()+"\n");
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String args[]){
        demo();
    }
}

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;

public class CallableThreadPool implements Callable {

    private Integer count;

    private  CountDownLatch latch ;


    //通过构造方法传递参数
    public CallableThreadPool(Integer count, CountDownLatch latch) {
        this.count = count;
        this.latch = latch;
    }

    @Override
    public Object call() throws Exception {
        Map<String,Object> returnMap = new HashMap<>();
        System.out.print(Thread.currentThread().getName()+":------"+count+"\n");
        //计数器减1
        latch.countDown();
        returnMap.put("顺序输出",count);
        return returnMap;//返回想要的结果
    }
}

四、输出结果如下

通过输出结果可以看出 我们是并发的执行任务，顺序输出线程池的返回结果 。