CountDownLatch应用

 核心模板

package cn.gdxiash.consumer.thread;

import cn.gdxiash.consumer.utils.ListUtil;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author ShangHai
 * @desc
 */
public class Exam {

    // 计数器
    private static CountDownLatch latch = null;

    // 执行状态
    private static boolean status = true;

    // 集合群
    private static List<List<String>> dataLists = null;

    // 集合群索引
    private static int listsIndex = 0;

    /**
     * 将一个数据集合平均分成若干个小数据集并存储，开启多线程对数据集群一一处理
     * @param dataList 数据集合
     */
    public static void testLatch(List<String> dataList){

        if(dataList==null || dataList.isEmpty()){
            return;
        }

        // CPU核心数 = 集合分割后,集合的数量
        int cpuNumber = Runtime.getRuntime().availableProcessors();

        if(dataList.size() < cpuNumber){
            cpuNumber = dataList.size();
        }

        // 计数器初始化
        latch = new CountDownLatch(cpuNumber);
        // 执行状态初始化
        status = true;
        // 集合群索引
        listsIndex = 0;
        // 集合群初始化（将一个集合内的元素平均分成cpuNumber个集合,然后循环分配给线程执行）
        dataLists = ListUtil.averageAssign(dataList, cpuNumber);

        // 以 CPU核心数或集合大小 创建固定大小的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(cpuNumber);

        for(int i=0; i<cpuNumber ;i++){
            executorService.execute(()->{
                try{
                    List<String> dataL;
                    synchronized(Exam.class) {
                        dataL = Exam.dataLists.get(Exam.listsIndex);
                        Exam.listsIndex++;
                    }
                    for(int j=0;j<dataL.size();j++){
                        System.out.print(dataL.get(j));
                        // 此处可以进行其他业务操作
                    }
                    System.out.println("\n--------------------");
                } catch(Exception e) {
                    Exam.status = false;
                    System.out.println("数据处理失败");
                } finally {
                    Exam.latch.countDown();
                }
            });
        }

        try{
            // 主线程等待线程池中的任务全部执行完毕
            Exam.latch.await();
        } catch(InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 清空数据集
            Exam.dataLists = null;
        }


        // 若任务全部正常执行，则可进一步处理
        if(Exam.status){
            System.out.println("数据正常执行完毕");
            // 此处可以进行其他业务操作
        }
    }
}

集合分割

package cn.gdxiash.consumer.utils;

import java.util.ArrayList;
import java.util.List;

/**
 * @author ShangHai
 * @desc
 */
public class ListUtil {

    /**
     * 将一个list均分成n个 list,主要通过偏移量来实现的
     * @param source 需要分割的数据集合
     * @param n 分割后几个数量
     * @param <T> 需要分割的集合
     * @return
     */
    public static <T> List<List<T>> averageAssign(List<T> source, int n){
        List<List<T>> result=new ArrayList<>();
        // 先计算出余数
        int remaider=source.size()%n;
        // 然后是商
        int number=source.size()/n;
        // 偏移量
        int offset=0;
        for(int i=0;i<n;i++){
            List<T> value;
            if(remaider>0){
                value=source.subList(i*number+offset, (i+1)*number+offset+1);
                remaider--;
                offset++;
            }else{
                value=source.subList(i*number+offset, (i+1)*number+offset);
            }
            result.add(value);
        }
        return result;
    }
    
}

main函数测试

public static void main(String[] args) {
        List<String> dataList = new ArrayList<>();
        dataList.add("A");
        dataList.add("B");
        dataList.add("C");
        dataList.add("D");
        dataList.add("E");
        dataList.add("F");
        dataList.add("G");
        dataList.add("H");
        dataList.add("I");
        dataList.add("J");
        Exam.testLatch(dataList);
    }

输出效果