线程池的使用

简单描述两个使用线程池的场景：

场景一：现在我们有一个需求，我们是一个商家来对接外渠，比如美团，我们可能在这个商家上有500家店，每家店有5000个商品(商品总量为5000，每家店可能有不同)，现在要拉取每家店的商品。

首先拿到上述需求的第一反应就是使用线程池去解决，因为商品的量级太大，下面简述下用Java实现的过程：

第一步是配置线程池(可以参考阿里巴巴规范，不做赘述)

@Configuration
public class ThreadPoolServiceConfig {

    @Bean
    public ThreadPoolExecutor assignThreadPool(){
     
        //corePoolSize:核心线程数
        //maximumPoolSize: 最大线程数量
        //keepAliveTime:存活时间
        //TimeUnit:存活单位
        //workQueue:存放需要执行的任务
        //threadFactory；线程工厂
        return new ThreadPoolExecutor(5, 10, 100L, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(50),
                new ThreadFactoryName("线程工厂名字"));
    }

}

PS：这里强调一下，核心线程数的确定需要根据当前服务器的核数来确定(这里又细分为CPU密集型和IO密集型两种)

//获取当前机器的核数(通常核心线程数用下面的cpuNum 来替换)

publicstaticfinalintcpuNum = Runtime.getRuntime().availableProcessors();

而最大线程数是核心线程数的两倍(上面没有具体的服务，就用数字代替了)

根据阿里巴巴规范要求我们的线程的名字一定要见名知意，所以还需要配置下线程名字，具体如下：

public class ThreadFactoryName implements ThreadFactory {

    private static final AtomicInteger POOL_NUMBER = new AtomicInteger(1);
    private final ThreadGroup group;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;

    ThreadFactoryName(String name){
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() :
                Thread.currentThread().getThreadGroup();
        if (StringUtils.isBlank(name)){
            name = "pool";
        }
        namePrefix = name +"-"+
                POOL_NUMBER.getAndIncrement() +
                "-thread-";
    }

    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(group, r,
                namePrefix + threadNumber.getAndIncrement(),
                0);
        if (t.isDaemon()) {
            t.setDaemon(false);
        }
        if (t.getPriority() != Thread.NORM_PRIORITY) {
            t.setPriority(Thread.NORM_PRIORITY);
        }
        return t;
    }

}

具体的使用如下：

//CountDownLatch 是一个计数器，用来阻塞线程，只有当所有
//的线程执行完毕，主线程才继续向下执行
//根据上面的场景假设有500家店，我们分为5组，一组100家店
CountDownLatch latch = new CountDownLatch(5);
//遍历，一次跑100家店
for (List<ThirdChannelWarehouseResVo> pageItem : thirdChannelWarehouseList) {
      threadPoolExecutor.execute(() -> {
         try {
                     //具体的业务逻辑
                        
                   } catch (Exception exception){
                       
                       //如果异常则将该集合全部存储，拉取失败需要有补偿机制
                       
                    } finally {
                        //执行完成计数减一
                        latch.countDown();
                    }
})
}
//阻塞等待计数器清0,则继续向下执行
            latch.await();

场景二：

在我们的分布式项目中，我们肯定会遇到多项目调用的情况，如下图：

我们肯定会优先选择下面的粗粒度调用方式(因为明显上面的调用方式服务挂掉的可能性要大于后者)

而采用下面的方式去调用，我们为了提高系统整个的性能，我们完全可以使用线程池的方式，将整个的调用任务抽出来，为此编写了下述的工具类：

package com.qianfeng.gp09.util;

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 同步调用的工具类
 * 内部封装线程池与CountDownLatch
 * 
 */
public class SyncBatchUtil {
    /**
     * 线程池
     */
    private static ExecutorService executorService;
    static{
        //核心线程数
        //计算密集  还是  IO密集
        //前者是 n  后者  是2n
        int corePoolSize=16;
        //最大线程数
        int maxPoolSize=32;
        //时间
        long keepAliveTime=10;
        //时间单位
        TimeUnit unit=TimeUnit.SECONDS;
        //队列
        BlockingQueue<Runnable> workQueue=new LinkedBlockingDeque<>();
        //工厂
        ThreadFactory threadFactory=new UserThreadFactory("GP09");
        //拒绝策略
        RejectedExecutionHandler handler=new MyRejectPolicy();

        //实例化线程池
        executorService=new ThreadPoolExecutor(corePoolSize,maxPoolSize,keepAliveTime,
                unit,workQueue,threadFactory,handler);
    }

    /**
     * 线程工厂
     */
    static class UserThreadFactory implements ThreadFactory{
        private final String namePrefix;
        private final AtomicInteger nextId=new AtomicInteger(1);

        public UserThreadFactory(String groupName) {
            this.namePrefix = "From "+SyncBatchUtil.class.getName()+
            "-"+groupName+"-";
        }

        @Override
        public Thread newThread(Runnable r) {
            String name=namePrefix+nextId.getAndIncrement();
            Thread thread=new Thread(null,r,name);
            return thread;
        }
    }

    /**
     * 拒绝策略
     */
    static class MyRejectPolicy implements RejectedExecutionHandler{
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            System.out.println(SyncBatchUtil.class.getName()+"的线程拒绝了");
        }
    }
    /**
     * 自定义任务
     */
    public static abstract class Task implements Runnable{
        /**
         * 任务调度的方法
         */
        public abstract void exe();

        /**
         * 内部封装的CountDownLatch
         */
        private CountDownLatch countDownLatch;

        public void setCountDownLatch(CountDownLatch countDownLatch) {
            this.countDownLatch = countDownLatch;
        }

        @Override
        public void run() {
            try{
                exe();
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                //再让计数器-1
                countDownLatch.countDown();
            }
        }
    }


    /**
     * 创建一组任务
     */
    private static boolean createTasks(Task [] tasks){
        //给这组任务分配一个CountDownLatch
        //注意：是一组任务对应一个CountDownLatch
        //用户每一次请求我们的服务器，都会导致我们有一组任务
        //因此其实是 每一次请求我们服务器，我们就要有一个CountDownLatch对象.
        //有多少个任务，计数器就是多少，所以构造方法的参数为task.length
        CountDownLatch countDownLatch =new CountDownLatch(tasks.length);
        //给每一个任务设定相同的countDownLatch
        for (int i = 0; i < tasks.length; i++) {
            tasks[i].setCountDownLatch(countDownLatch);
        }

        //每一个task类型其实都是Runnable类型，它应该用线程池来执行
        for (int i = 0; i < tasks.length; i++) {
            //启动每一个任务
            executorService.execute(tasks[i]);
        }
        //卡住当前线程
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }


    /**
     * 给外界提供可调用的方法
     * @param tasks 指定一组任务
     * @return 这组任务是否创建成功
     */
    public static boolean batch(Task ... tasks){
        return createTasks(tasks);
    }
}

 下面是测试：

package com.qianfeng.gp09.util;




public class SyncBatchUtilTest {
    public static void main(String[] args) {
        System.out.println("当前线程开始执行");
        SyncBatchUtil.batch(new SyncBatchUtil.Task() {
            @Override
            public void exe() {
                System.out.println("第一个线程开始执行");
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("第一个线程执行完毕");
            }
        }, new SyncBatchUtil.Task() {
            @Override
            public void exe() {
                System.out.println("第二个线程开始执行");
                try {
                    Thread.sleep(4000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("第二个线程执行完毕");
            }
        }, new SyncBatchUtil.Task() {
            @Override
            public void exe() {
                System.out.println("第三个线程开始执行");
                try {
                    Thread.sleep(6000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("第三个线程执行完毕");
            }
        });

        System.out.println("当前线程执行完毕");
    }
}