线程池+Java循环+主线程等待子线程完毕

线程池–Java循环–主线程等待子线程完毕

创建线程池

/**
 * 线程池配置类
 *
 */
@Configuration
@EnableAsync
public class ExecutorConfig {

    /**
     * 核心线程数
     * 默认的核心线程数为1
     *
     */
    private static final int CORE_POOL_SIZE = 3;
    /**
     * 最大线程数
     * 默认的最大线程数是Integer.MAX_VALUE 即2<sup>31</sup>-1
     */
    private static final int MAX_POOL_SIZE = 5;
    /**
     * 缓冲队列数
     * 默认的缓冲队列数是Integer.MAX_VALUE 即2<sup>31</sup>-1
     */
    private static final int QUEUE_CAPACITY = 20;

    /**
     * 允许线程空闲时间
     * 默认的线程空闲时间为60秒
     */
    private static final int KEEP_ALIVE_SECONDS = 30;

    /**
     * 线程池前缀名
     */
    private static final String THREAD_NAME_PREFIX = "async_thread_";

    /**
     * allowCoreThreadTimeOut为true则线程池数量最后销毁到0个
     * allowCoreThreadTimeOut为false
     * 销毁机制：超过核心线程数时，而且（超过最大值或者timeout过），就会销毁。
     * 默认是false
     */
    private boolean allowCoreThreadTimeOut = false;

    @Bean("aysncExecutor")
    public ThreadPoolTaskExecutor taskExecutor() {

        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        taskExecutor.setCorePoolSize(CORE_POOL_SIZE);
        taskExecutor.setMaxPoolSize(MAX_POOL_SIZE);
        taskExecutor.setQueueCapacity(QUEUE_CAPACITY);
        taskExecutor.setKeepAliveSeconds(KEEP_ALIVE_SECONDS);
        taskExecutor.setThreadNamePrefix(THREAD_NAME_PREFIX);
        taskExecutor.setAllowCoreThreadTimeOut(allowCoreThreadTimeOut);
        taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        //线程池初始化
        taskExecutor.initialize();
        return taskExecutor;
    }
}

处理循环逻辑

一、SpringBoot整合线程池，注入方式

/**
 * 产品订购
 */
@Service
@Slf4j
public class TestExecutorServiceImpl implements TestExecutorService {
    
    /**
     * 注入线程池对象，自动装配
     */
    @Autowired
    private ExecutorConfig executorConfig;
    
     /**
      * 测试 线程池 处理 for循环
      * @param test
      */
    @Override
    public Map<String, Object> testExecutorForeach(List<Long> testList)  {
        //线程计数器
         final CountDownLatch latch = new CountDownLatch(testList.size());
        
        // 遍历
        for (Long test : testList) {
            Runnable run = () -> {
                try {
                   System.out.println("我在执行=" + test); 
                }finally {
                    //每次调用CountDown()，计数减1
                    latch.countDown();
                }
            };
            executorConfig.taskExecutor().execute(run);
        }
        
        try {
            //等待所有线程执行完毕
            latch.await();//主程序执行到await()函数会阻塞等待线程的执行，直到计数为0
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
    }
    
}

二、手动创建线程池–(执行完后记得关闭线程池)

newCachedThreadPool：可变尺寸线程池，这种方式的特点是：可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。
newFixedThreadPool的参数指定了可以运行的线程的最大数目，超过这个数目的线程加进去以后，不会运行。其次，加入线程池的线程属于托管状态，线程的运行不受加入顺序的影响。
二者的区别就是在创建线程池对象的时候的参数不一样。
ExecutorService taskExecutor = Executors.newFixedThreadPool(2);//创建2个线程。
ExecutorService taskExecutor = Executors.newCachedThreadPool();//根据线程创建线程

//数据库中的100条数据;
List list =new ArrayList();
for (int i = 0; i <100 ; i++) {
    list.add(i);
}
//Executors创建线程池new固定的10个线程
ExecutorService taskExecutor  = Executors.newCachedThreadPool();
final CountDownLatch latch = new CountDownLatch(list.size());//用于判断所有的线程是否结束
System.out.println("个数=="+list.size());
for (int m = 0; m < list.size(); m++) {
    final int n = m;//内部类里m不能直接用,所以赋值给n
    Runnable run = new Runnable() {
        public void run() {
            try {
                System.out.println("我在执行="+n); 
            }finally {
                latch.countDown(); //每次调用CountDown()，计数减1
            }
        }
    };
    taskExecutor.execute(run);//开启线程执行池中的任务。还有一个方法submit也可以做到，它的功能是提交指定的任务去执行并且返回Future对象，即执行的结果
}
try {
    //等待所有线程执行完毕
    latch.await();//主程序执行到await()函数会阻塞等待线程的执行，直到计数为0
} catch (InterruptedException e) {
    e.printStackTrace();
}
taskExecutor.shutdown();//关闭线程池
//所有线程执行完毕,执行主线程

}