并行处理集合List Demo

并行处理集合List Demo

在实际的业务场景中经常出现一个集合需要轮询处理,可以使用Java提供的ExecutorService来处理

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.concurrent.*;

/**
 * 多线程并发处理一个List集合
 */
public class ExecutorsTheadDemo {

    /**
     * 通过多线程进行集合处理
     *
     * @param inDataList
     * @return
     */
    public List<HashMap<String, String>> dataList(List<HashMap<String, String>> inDataList) {
        List<HashMap<String, String>> rtList = new ArrayList<HashMap<String, String>>();
        // 开始时间
        long start = System.currentTimeMillis();
        // 设置每个线程处理集合的大小
        int threadSize = 50;
        // 获取数据集合大小
        int dataSize = inDataList.size();
        // 线程数
        int threadNum = dataSize / threadSize + 1;
        // 定义标记,过滤threadNum为整数
        boolean special = dataSize % threadSize == 0;

        // 创建处理集合的线程池
        ExecutorService execPool = Executors.newFixedThreadPool(threadNum);

        // 定义任务集合
        List<Callable<List<HashMap<String, String>>>> tasksList = new ArrayList<Callable<List<HashMap<String, String>>>>();
        // 定义任务对象
        Callable<List<HashMap<String, String>>> task = null;
        // 定义任务内集合对象
        List<HashMap<String, String>> curentList = null;
        // 确定每个任务范围
        for (int i = 0; i < threadNum; i++) {
            if (i == threadNum - 1) {
                if (special) {
                    break;
                }
                curentList = inDataList.subList(threadSize * i, dataSize);
            } else {
                curentList = inDataList.subList(threadSize * i, threadSize * (i + 1));
            }
            //构造初始化任务对象
            task = new DataTaskCallable(curentList, i+1);
            //这里提交的任务容器列表和返回的Future列表存在顺序对应的关系
            tasksList.add(task);
        }

        try {
            // 发起线程处理
            List<Future<List<HashMap<String, String>>>> execResult = execPool.invokeAll(tasksList);
            // 获取结果
            for (Future<List<HashMap<String, String>>> future : execResult) {
                try {
                    rtList.addAll(future.get());
                } catch (ExecutionException e) {
                    e.printStackTrace();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 关闭线程池
        execPool.shutdown();
        return rtList;
    }

    // 集合内部自己处理
    class DataTaskCallable implements Callable<List<HashMap<String, String>>> {

        // 定义处理的集合对象
        private List<HashMap<String, String>> list;

        // 线程对象
        private int threadNum;

        // 提供初始化构造函数
        public DataTaskCallable(List<HashMap<String, String>> list, int threadNum) {
            this.list = list;
            this.threadNum = threadNum;
        }

        @Override
        public List<HashMap<String, String>> call() throws Exception {
            // 对list进行业务处理
            for (HashMap map : list) {
                map.put("ADD" + threadNum, threadNum);
            }
            System.out.println("ThreadNum:"+threadNum);
            return list;
        }
    }

    public static void main(String[] args) {
        List<HashMap<String,String>> dataList = new ArrayList<HashMap<String, String>>();

        // 模拟集合数据
        for (int i = 0 ;i <500 ; i++){
            HashMap<String,String> map = new HashMap<String,String>();
            map.put(""+System.currentTimeMillis(),""+System.currentTimeMillis());
            dataList.add(map);
        }
        new ExecutorsTheadDemo().dataList(dataList);