All Downloads are FREE. Search and download functionalities are using the official Maven repository.
Please wait. This can take some minutes ...
Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.voovan.tools.threadpool.ThreadPool Maven / Gradle / Ivy
package org.voovan.tools.threadpool;
import org.voovan.tools.TEnv;
import org.voovan.tools.TProperties;
import org.voovan.tools.log.Logger;
import java.util.Timer;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* 线程池
*
* @author helyho
*
* Voovan Framework.
* WebSite: https://github.com/helyho/Voovan
* Licence: Apache v2 License
*/
public class ThreadPool {
private static int cpuCoreCount = Runtime.getRuntime().availableProcessors();
protected static int MIN_POOL_SIZE = cpuCoreCount;
protected static int MAX_POOL_SIZE = cpuCoreCount;
protected static int STATUS_INTERVAL = 5000;
protected static int minPoolSize = TProperties.getInt("framework", "ThreadPoolMinSize");
protected static int maxPoolSize = TProperties.getInt("framework", "ThreadPoolMaxSize");
protected static ConcurrentHashMap THREAD_POOL_HANDLER = new ConcurrentHashMap();
/**
* 获取线程池最小活动线程数
* @return 线程池最小活动线程数
*/
public static int getMinPoolSize() {
MIN_POOL_SIZE = minPoolSize == -1 ? cpuCoreCount : minPoolSize;
return MIN_POOL_SIZE;
}
/**
* 获取线程池最大活动线程数
* @return 线程池最大活动线程数
*/
public static int getMaxPoolSize() {
if(maxPoolSize > maxPoolSize){
maxPoolSize = maxPoolSize;
}
MAX_POOL_SIZE = maxPoolSize == -1 ? cpuCoreCount : maxPoolSize;
return MAX_POOL_SIZE;
}
/**
* 获取线程池最大活动线程数
* @return 线程池最大活动线程数
*/
public static int getStatusInterval() {
STATUS_INTERVAL = TProperties.getInt("framework", "ThreadPoolStatusInterval", 0);
return STATUS_INTERVAL;
}
static{
getMinPoolSize();
getMaxPoolSize();
getStatusInterval();
}
private ThreadPool(){
}
/**
* 使用默认配置构造线程池, 配置来自于 fraemwork.properties
* @param poolName 线程池名称
* @return 线程池对象
*/
public static ThreadPoolExecutor createThreadPool(String poolName){
Logger.simple("[THREAD_POOL] " + poolName + " Min size: " + MIN_POOL_SIZE);
Logger.simple("[THREAD_POOL] " + poolName + " Max size: " + MAX_POOL_SIZE);
ThreadPoolExecutor threadPoolInstance = createThreadPool(poolName, MIN_POOL_SIZE, MAX_POOL_SIZE, 1000*60);
//启动线程池自动调整任务
if(STATUS_INTERVAL>0) {
Timer timer = new Timer("VOOVAN@THREAD_POOL_TIMER", true);
ThreadPoolTask threadPoolTask = new ThreadPoolTask(threadPoolInstance);
timer.schedule(threadPoolTask, 1, 1000);
}
return threadPoolInstance;
}
/**
* 创建线程池
* @param poolName 池的名称
* @param mimPoolSize 最小线程数
* @param maxPoolSize 最大线程数
* @param keepAliveTime 线程闲置最大存活时间,单位: 毫秒
* @return 线程池对象
*/
public static ThreadPoolExecutor createThreadPool(String poolName, int mimPoolSize, int maxPoolSize, int keepAliveTime){
return createThreadPool(poolName, mimPoolSize, maxPoolSize, keepAliveTime, true , 5);
}
/**
* 创建线程池
* @param poolName 池的名称
* @param mimPoolSize 最小线程数
* @param maxPoolSize 最大线程数
* @param keepAliveTime 线程闲置最大存活时间, 单位: 毫秒
* @param daemon 是否是守护线程
* @param priority 线程优先级
* @return 线程池对象
*/
public static ThreadPoolExecutor createThreadPool(String poolName, int mimPoolSize, int maxPoolSize, int keepAliveTime, boolean daemon, int priority) {
return createThreadPool(poolName, mimPoolSize, maxPoolSize, keepAliveTime, daemon, priority, cpuCoreCount * 100);
}
/**
* 创建线程池
* @param poolName 池的名称
* @param mimPoolSize 最小线程数
* @param maxPoolSize 最大线程数
* @param keepAliveTime 线程闲置最大存活时间, 单位: 毫秒
* @param daemon 是否是守护线程
* @param priority 线程优先级
* @param queueSize 线程池任务队列大小
* @return 线程池对象
*/
public static ThreadPoolExecutor createThreadPool(String poolName, int mimPoolSize, int maxPoolSize, int keepAliveTime, boolean daemon, int priority, int queueSize){
ThreadPoolExecutor threadPoolInstance = THREAD_POOL_HANDLER.get(poolName);
if(threadPoolInstance==null) {
threadPoolInstance = new ThreadPoolExecutor(mimPoolSize, maxPoolSize, keepAliveTime, TimeUnit.MILLISECONDS, new ArrayBlockingQueue(queueSize), new FastThreadFactory(poolName, daemon, priority));
//设置allowCoreThreadTimeOut,允许回收超时的线程
threadPoolInstance.allowCoreThreadTimeOut(true);
THREAD_POOL_HANDLER.put(poolName, threadPoolInstance);
ThreadPoolExecutor finalThreadPoolInstance = threadPoolInstance;
//绑定进程结束,自动停止线程池
TEnv.addShutDownHook(()->{
finalThreadPoolInstance.shutdown();
});
}
return threadPoolInstance;
}
/**
* 平滑的关闭线程池
* @param threadPoolExecutor 线程池对象
*/
public static void gracefulShutdown(ThreadPoolExecutor threadPoolExecutor) {
threadPoolExecutor.shutdown();
TEnv.wait(()-> !threadPoolExecutor.isShutdown());
}
}