Java常用线程池-固定线程池使用

固定线程池

在执行数据处理时不可避免的需要使用多线程进行数据处理，以此提高数据处理效率，降低处理时间。而线城池现在池容器对数据处理效率提升有举足轻重的作用，一般我们会在实际应用中使用固定线程池。

package com.base.service;

import com.base.service.common.loghub.LogHubAdapter;
import com.base.service.common.loghub.LogHubFactoryAdapter;
import com.google.common.collect.Lists;
import org.apache.commons.collections.CollectionUtils;
import org.slf4j.LoggerFactory;

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

/**
 * Description
 *
 * @Author: xuxin
 * @Date: 2020/4/30 18:25
 * @Version 1.0
 */
public class FixedThreadPoolTest {
    /**
     * 自定义线程池
     */
    private  final  static ExecutorService EXECUTOR = Executors.newFixedThreadPool(12);
    /**
     * log工具
     */
    private final static LogHubAdapter loghub  = LogHubFactoryAdapter.getLoghubAdapter(this.getClass(), LoggerFactory.getLogger(this.getClass()));

    public static void main(String[] args) {

        List list= Lists.newArrayList();
        list.add("1");list.add("2");list.add("3");list.add("4");list.add("5");

        Object lock=new Object();
        try {
            if (CollectionUtils.isNotEmpty(list) && list.size()>0){
                /**
                 * 1、CountDownLatch这个类使一个线程等待其他线程各自执行完毕后再执行
                 * 2、它是通过一个计数器实现，计数器的初始值是线程的数量。每当一个线程执行完毕后，
                 *   计数器的值就-1，当计数器值为0时，表示所有线程都执行完毕，
                 *    然后再闭锁上等待的线程就可以恢复工作了。
                 */
                CountDownLatch countDownLatch=new CountDownLatch(list.size());
                list.forEach(s->{
                    EXECUTOR .execute(()->{
                        try {
                            //逻辑操作。在并发编程中存在线程安全问题。主要原因：1、存在共享数据 2、多线程共同操作共享数据。
                            //synchronized可以保证在同一时刻，只有一个线程可以执行某个方法或者代码块
                            //同时synchronized可以保证一个线程变化可见性，可以代替volatile
                            synchronized (lock){
                                loghub.info(s);
                            }
                        }catch (Exception e){
                            loghub.error("查询错误",e);
                        }finally {
                            //正常执行或者异常都要-1
                            countDownLatch.countDown();
                        }
                    });
                });
                try {
                    //等待12s，只不过等待一定时间后count值还没变为0的话就会继续执行
                    countDownLatch.await(12, TimeUnit.SECONDS);
                }catch (Exception e){
                    loghub.error("请求超时",e);
                }
            }
        }catch (Exception e){
            loghub.error("报错",e);
        }
    }

}