线程池管理工具类

 

各位读者，大家好！

   

   我们在项目开发过程中，经常会使用线程池管理，特别是对TPS有一定要求的情况。

   线程池会自动帮助我们管理线程的创建、回收及销毁等工作，方便我们的开发。特别有异步需求、调用第三方系统且比较耗时的批量任务，都可以使用线程池很好的帮我们节省大量时间，提高用户的体验。

 

   比如：小美想从XX系统进行贷款，那么XX系统肯定需要获取小美的人行征信，还可能需要校验小美是否从此种同类的系统已经贷款，如果贷款了，那么就不能再次贷款。这里牵扯到2个第三方系统，人行征信系统 及 贷款信息汇总系统，假设从人行征信系统获取征信需要5s，取贷款信息汇总系统需要3s，那么按照正常的同步流程：先获取征信，再获取贷款信息，就一共需要8s；那么如果再加上其他各种各样的校验、第三方外调（甚至外调超时），那么加起来时间更长，对客户的体验肯定会受影响，可能就会丢失小美这样大量的客户。

    所以，我们可以使用线程池来做这件事情，让A线程去调人行征信，让B线程去获取贷款信息，让C线程去调其他第三方依赖系统....,这样，一旦任何一个线程得到不符合贷款的校验结果，就返回并通知终止其他线程。这样，客户等待的时间就成倍节约下来，理论上最好情况是等待了花费最长的那个线程的时间。不仅如此，假设所有线程校验都通过，我们需要等待以上所有线程执行完毕，才可以继续接下来的工作，这个时候我们就可以用到本次介绍的工具类中awaitTasksFinished方法即可。

    以下是该线程管理工具的完整代码：

 

package com.cheng2839.utils;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.CollectionUtils;

import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 线程池工具类
 *
 * @author cheng2839
 * @date 2018年11月16日
 */
public final class ThreadPoolFactory {

    private static final Logger logger = LoggerFactory.getLogger(ThreadPoolFactory.class);

    private static ThreadPoolFactory factory = new ThreadPoolFactory();

    //线程池默认配置设置
    private static final int CORE_POOL_SIZE = 5;
    private static final int MAXIMUM_POOL_SIZE = 20;
    private static final long KEEP_ALIVE_TIME = 60L;

    private ThreadPoolFactory() {
    }

    public static ThreadPoolFactory getFactory() {
        if (factory == null) {
            factory = new ThreadPoolFactory();
        }
        return factory;
    }

    /**
     * 创建一个默认的线程池
     *
     * @return
     * @author cheng2839
     * @date 2018年11月16日
     */
    public ExecutorService getDefaultThreadPool() {
        //配置最大队列容量
        BlockingQueue<Runnable> blockingQueue = new LinkedBlockingQueue<>(Integer.MAX_VALUE);
        return getCustomThreadPool(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_TIME, blockingQueue);
    }

    /**
     * 创建一个简单的线程池
     *
     * @return
     * @author cheng2839
     * @date 2018年11月16日
     */
    public ExecutorService getSimpleThreadPool(int corePoolSize, int maximumPoolSize) {
        return getCustomThreadPool(corePoolSize, maximumPoolSize, KEEP_ALIVE_TIME, new LinkedBlockingQueue<Runnable>());
    }

    /**
     * 创建一个指定队列的线程池
     *
     * @return
     * @author cheng2839
     * @date 2018年11月16日
     */
    public ExecutorService getCustomQueueThreadPool(int corePoolSize, int maximumPoolSize, BlockingQueue<Runnable> blockingQueue) {
        return getCustomThreadPool(corePoolSize, maximumPoolSize, KEEP_ALIVE_TIME, blockingQueue);
    }

    /**
     * 创建可跟踪任务状态的执行器
     *
     * @return
     * @author cheng2839
     * @date 2018年11月16日
     */
    public ExecutorCompletionService getCompletionService(ExecutorService executorService) {
        return new ExecutorCompletionService(executorService);
    }

    /**
     * 创建一个定制化的线程池
     *
     * @return
     * @author cheng2839
     * @date 2018年11月16日
     */
    public ExecutorService getCustomThreadPool(int corePoolSize,
                                               int maximumPoolSize,
                                               Long keepAliveTime,
                                               BlockingQueue<Runnable> blockingQueue) {
        logger.info("开始初始化线程池[corePoolSize={},maximumPoolSize={},keepAliveTime={}s]...", corePoolSize, maximumPoolSize, keepAliveTime);

        RejectedExecutionHandler rejectedExecutionHandler = (Runnable r, ThreadPoolExecutor executor) -> {
            logger.error("线程池已满，任务被丢弃...........................");
            return;
        };
        ExecutorService executorService = new ThreadPoolExecutor(corePoolSize,
                maximumPoolSize,
                keepAliveTime,
                TimeUnit.SECONDS,
                blockingQueue,
                rejectedExecutionHandler);
        logger.info("初始化线程池完成！");
        return executorService;
    }

    /**
     * 等待任务执行完成 并 释放连接池
     *
     * @param futureList
     * @param completionService
     * @param <V>
     * @author cheng2839
     * @date 2018年11月16日
     */
    public <V> void awaitTasksFinished(List<Future> futureList, CompletionService<V> completionService) {
        try {
            if (!CollectionUtils.isEmpty(futureList) && completionService != null) {
                logger.info("等待批量任务[{}]执行。。。", futureList.size());
                for (int n = 0; n < futureList.size(); n++) {
                    Future future = completionService.take();
                    if (future != null)
                        future.get();
                }
            }
        } catch (Exception e) {
            logger.error("多线程获取结果异常: {}", e);
        }
    }

    /**
     * 关闭线程池
     *
     * @param executorService
     * @author cheng2839
     * @date 2018年11月16日
     */
    public void shutdown(ExecutorService executorService) {
        try {
            if (executorService != null) {
                logger.info("关闭线程池:{}", executorService);
                executorService.shutdown();
            }
        } catch (Exception e) {
            if (!executorService.isTerminated()) {
                executorService.shutdownNow();
            }
        } finally {
            try {
                if (executorService != null && !executorService.isShutdown()) {
                    executorService.shutdown();
                }
            } catch (Exception e) {
                logger.error("线程池关闭异常：{}", e);
            }
        }
    }

}

 

    运行示例略，大家可以根据自己的需求灵活运用！

 

    源码归本人所有，如需转载，请标注出处。

 

我还是忍不住放上了这张图片，万一你想和我说说话呢😄❀