java线程池分段处理list集合

package com.chenva.main.util;
import java.util.*;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TheardPoolTest  {

    public static void main(String[] args) throws InterruptedException {
        theardPoolTest();
//        theardPoolTest2();

    }

    //方式一  线程处理固定集合处理
    public static void theardPoolTest() throws InterruptedException {
        List<String> testList = new ArrayList<>(500001);
        for (int i = 0; i < 500001; i++) {
            testList.add(i+"");
        }
        /**
         * Executors.newFixedThreadPool(有参)创建固定大小的线程池
         * 特点：可控制并发的线程数，超出的线程会在等待队列中等待
         *Executors.newCachedThreadPool();创建一个可缓存的线程池
         * 特点若线程超过处理所需，会在线程空闲时回收，若线程数无法满足任务数则创建新的线程，
         * 适用于短时间高并发，消耗资源大
         * Executors.newScheduledThreadPool(5)；延迟线程
         */

        //集合分段
        int listSize = 10000;//每个集合分100条数据
        int size = testList.size();//集合总大小
        int poolList = size / listSize + 1;//线程池数量
        //创建固定大小的线程池
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(poolList);
        //接收一个int型参数，表示要等待的线程个数
        CountDownLatch countDownLatch = new CountDownLatch(poolList);//等待其他线程完成
        //切分每个线程处理的集合转为线程安全集合
        List<String> strings = Collections.synchronizedList(new ArrayList<>());
        for (int i = 0; i < poolList; i++) {
            List<String> arryList = null;//定义每个线程要处理的集合
            if((i+1) == poolList){
                arryList = testList.subList(i*listSize,size);
            }else{
                arryList = testList.subList(i*listSize,(i+1)*listSize);
            }
            //开启线程
            List<String> finalArryList = arryList;
            fixedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    //业务处理
                    for (String s: finalArryList) {
                        strings.add(s);
                        System.out.println("我是第"+s+"条数据");
                        System.out.println("我是被线程"+Thread.currentThread().getName()+"执行的");
                    }
                    System.out.println("我被减1");//等待数减1
                    countDownLatch.countDown();
                }
            });
        }
        //等待数减到0时开始执行表示主线程已执行完毕,释放阻塞
        countDownLatch.await();
        fixedThreadPool.shutdown();//关闭线程池
        while (true){
            //子线程执行完毕
            if (fixedThreadPool.isTerminated()){

                /*for(String s:strings){//测试500条数据全部放了进去且不规律
                    System.out.println("测试数据"+s);
                }*/
                System.out.println("数据大小"+strings.size());
                break;
            }
        }
    }

    //方式2 随机分配线程执行的数据
    public static void theardPoolTest2() throws InterruptedException {
        List<String> testList = new ArrayList<>(50000);
        for (int i = 0; i < 500000; i++) {
            testList.add(i + "");
        }
        /**
         * Executors.newFixedThreadPool(有参)创建固定大小的线程池
         * 特点：可控制并发的线程数，超出的线程会在等待队列中等待
         *Executors.newCachedThreadPool();创建一个可缓存的线程池
         * 特点若线程超过处理所需，会在线程空闲时回收，若线程数无法满足任务数则创建新的线程，
         * 适用于短时间高并发，消耗资源大
         * Executors.newScheduledThreadPool(5)；延迟线程
         */

        //集合分段
        int listSize = 10000;//每个集合分100条数据
        int size = testList.size();//集合总大小
        int poolList = size / listSize + 1;//线程池数量
        //创建固定大小的线程池
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(poolList);
        //切分每个线程处理的集合
        List<String> strings = Collections.synchronizedList(new ArrayList<>());
        for (int i = 0; i < testList.size(); i++) {
            final int finalI = i;
            fixedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    strings.add("s" + finalI);
                    System.out.println("我是第" + finalI + "条数据");
                    System.out.println("我是被线程" + Thread.currentThread().getName() + "执行的");
                }
            });
        }
        fixedThreadPool.shutdown();//关闭线程池
        while (true) {
            //子线程执行完毕
            if (fixedThreadPool.isTerminated()) {
                System.out.println("线程已全部执行完毕");
                /*for(String s:strings){//测试500条数据全部放了进去且不规律
                    System.out.println("测试数据"+s);
                }*/
                System.out.println("数据大小" + strings.size());
                break;
            }

        }
    }
}