Java并发编程实战~线程池创建

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import com.google.common.util.concurrent.ThreadFactoryBuilder;

/**
 * TODO 在此写上类的相关说明.<br>
 * @author gqltt<br>
 * @version 1.0.0 2021年11月29日<br>
 * @see 
 * @since JDK 1.5.0
 */
public class ThreadPoolExecutorBuilder {
	
	/**
	 * 单例.
	 */
	private static final ThreadPoolExecutorBuilder instance = 
			new ThreadPoolExecutorBuilder();
	/**
	 * 线程池.
	 */
	private static Map<String, ThreadPoolExecutor> threadPoolMap = 
			new ConcurrentHashMap<>();
	
	/**
	 * 获取单例.
	 * @return
	 */
	public static ThreadPoolExecutorBuilder getInstance() {
		return instance;
	}
	
	/**
	 * 获取线程池对象.
	 * @param threadNamePrefix 线程名称前缀.
	 * @param corePoolSize 核心线程数量.
	 * @param maxPoolSize 最大线程数量.
	 * @param keepAliveSeconds 空闲秒数.
	 * @param queueSize 阻塞队列长度.
	 * @return 线程池对象.
	 */
	public ThreadPoolExecutor getThreadPoolExecutor(final String threadNamePrefix, 
			final int corePoolSize, final int maxPoolSize, 
			final long keepAliveSeconds, final int queueSize) {

		return getThreadPoolExecutor(threadNamePrefix, 
				corePoolSize, maxPoolSize, 
				keepAliveSeconds, queueSize, 
				new ThreadPoolExecutor.AbortPolicy());
	}
	
	/**
	 * 获取线程池对象.
	 * @param threadNamePrefix 线程名称前缀.
	 * @param corePoolSize 核心线程数量.
	 * @param maxPoolSize 最大线程数量.
	 * @param keepAliveSeconds 空闲秒数.
	 * @param queueSize 阻塞队列长度.
	 * @param handler 丢失策略.
	 * @return 线程池对象.
	 */
	public ThreadPoolExecutor getThreadPoolExecutor(final String threadNamePrefix, 
			final int corePoolSize, final int maxPoolSize, 
			final long keepAliveSeconds, final int queueSize,
			final RejectedExecutionHandler handler) {
		
		// 已有指定线程池，直接获取返回.
		if (threadPoolMap.get(threadNamePrefix) != null) {
			return threadPoolMap.get(threadNamePrefix);
		}
		
		synchronized (threadPoolMap) {
			// 二次检查.
			if (threadPoolMap.get(threadNamePrefix) != null) {
				return threadPoolMap.get(threadNamePrefix);
			}
			
			// 线程创建指定名称前缀.
			final ThreadFactory factory = 
					new ThreadFactoryBuilder().setNameFormat(threadNamePrefix + "%s").build();
			// 线程池.
			final ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maxPoolSize, 
								keepAliveSeconds, TimeUnit.SECONDS, 
								new LinkedBlockingQueue<Runnable>(queueSize), 
								factory, 
								handler);
			addShutdownHook(executor);
			threadPoolMap.put(threadNamePrefix, executor);
		}
		
		return threadPoolMap.get(threadNamePrefix);
	}
	
	/**
	 * 添加关闭系统钩子.
	 */
	private void addShutdownHook(final ThreadPoolExecutor executor) {
		Runtime.getRuntime().addShutdownHook(new Thread(() -> {
			executor.shutdown();
			try {
				// 最长等待30秒，线程池所有任务执行.
				if (!executor.awaitTermination(30, TimeUnit.SECONDS)) {
					executor.shutdownNow();
				}
			} catch (Exception e) {
				executor.shutdownNow();
			}
		}));
	}
}