java 注解实现一个可配置线程池的方法示例
发布于 2020-7-17|
复制链接
摘记: 前言项目需要多线程执行一些Task,为了方便各个服务的使用。特意封装了一个公共工具类,下面直接撸代码:PoolConfig(线程池核心配置参数):
```java
/**
* 线程池核心配置( ..
前言项目需要多线程执行一些Task,为了方便各个服务的使用。特意封装了一个公共工具类,下面直接撸代码:PoolConfig(线程池核心配置参数):
```java
/**
* 线程池核心配置(基本线程池数量、最大线程池数量、队列初始容量、线程连接保持活动秒数(默认60s))
*
*
*
*
* 属性名称
*
* 属性含义
*
*
* queueCapacity
*
* 基本线程池数量
*
*
* count
*
* 最大线程池数量
*
*
* maxCount
*
* 队列初始容量
*
*
* aliveSec
*
* 线程连接保持活动秒数(默认60s)
*
*
*
*/
public class PoolConfig {
private int queueCapacity = 200;
private int count = 0;
private int maxCount = 0;
private int aliveSec;
public int getQueueCapacity() {
return queueCapacity;
}
public void setQueueCapacity(int queueCapacity) {
this.queueCapacity = queueCapacity;
}
public void setCount(int count) {
this.count = count;
}
public void setMaxCount(int maxCount) {
this.maxCount = maxCount;
}
public void setAliveSec(int aliveSec) {
this.aliveSec = aliveSec;
}
public int getCount() {
return count;
}
public int getMaxCount() {
return maxCount;
}
public int getAliveSec() {
return aliveSec;
}
}
```
ThreadPoolConfig(线程池配置 yml配置项以thread开头):
```java
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
/**
* 线程池配置(线程池核心配置、各个业务处理的任务数量)
*
*
*
*
* 属性名称
*
* 属性含义
*
*
* pool
*
* 线程池核心配置
* 【{@link PoolConfig}】
*
*
* count
*
* 线程池各个业务任务初始的任务数
*
*
*
*/
@Component
@ConfigurationProperties(prefix="thread")
public class ThreadPoolConfig {
private PoolConfig pool = new PoolConfig();
Map count = new HashMap();
public PoolConfig getPool() {
return pool;
}
public void setPool(PoolConfig pool) {
this.pool = pool;
}
public Map getCount() {
return count;
}
}
```
定义Task注解,方便使用:
```java
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface ExcutorTask {
/**
* The value may indicate a suggestion for a logical ExcutorTask name,
* to be turned into a Spring bean in case of an autodetected ExcutorTask .
* @return the suggested ExcutorTask name, if any
*/
String value() default "";
}
```
通过反射获取使用Task注解的任务集合:
```java
public class Beans {
private static final char PREFIX = '.';
public static ConcurrentMap scanBeanClassNames(){
ConcurrentMap beanClassNames = new ConcurrentHashMap();
ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(false);
provider.addIncludeFilter(new AnnotationTypeFilter(ExcutorTask.class));
for(Package pkg : Package.getPackages()){
String basePackage = pkg.getName();
Set components = provider.findCandidateComponents(basePackage);
for (BeanDefinition component : components) {
String beanClassName = component.getBeanClassName();
try {
Class clazz = Class.forName(component.getBeanClassName());
boolean isAnnotationPresent = clazz.isAnnotationPresent(ZimaTask.class);
if(isAnnotationPresent){
ZimaTask task = clazz.getAnnotation(ExcutorTask.class);
String aliasName = task.value();
if(aliasName != null && !"".equals(aliasName)){
beanClassNames.put(aliasName, component.getBeanClassName());
}
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
beanClassNames.put(beanClassName.substring(beanClassName.lastIndexOf(PREFIX) + 1), component.getBeanClassName());
}
}
return beanClassNames;
}
}
```
线程执行类TaskPool:
```java
@Component
public class TaskPool {
public ThreadPoolTaskExecutor poolTaskExecutor;
@Autowired
private ThreadPoolConfig threadPoolConfig;
@Autowired
private ApplicationContext context;
private final Integer MAX_POOL_SIZE = 2000;
private PoolConfig poolCfg;
private Map tasksCount;
private ConcurrentMap beanClassNames;
@PostConstruct
public void init() {
beanClassNames = Beans.scanBeanClassNames();
poolTaskExecutor = new ThreadPoolTaskExecutor();
poolCfg = threadPoolConfig.getPool();
tasksCount = threadPoolConfig.getCount();
int corePoolSize = poolCfg.getCount(),
maxPoolSize = poolCfg.getMaxCount(),
queueCapacity = poolCfg.getQueueCapacity(),
minPoolSize = 0, maxCount = (corePoolSize 0){
if(corePoolSize 0){
poolTaskExecutor.setQueueCapacity(queueCapacity);
}
if(corePoolSize > 0){
if(MAX_POOL_SIZE 0){
if(maxPoolSize 0){
poolTaskExecutor.setKeepAliveSeconds(poolCfg.getAliveSec());
}
poolTaskExecutor.initialize();
}
public void execute(Class... clazz){
int i = 0, len = tasksCount.size();
for(; i clazz = Class.forName(beanClassNames.get(args[i].toLowerCase()));
taskObj = context.getBean(clazz);
}
}
if(taskObj != null){
poolTaskExecutor.execute((Runnable) taskObj);
}
}catch(Exception ex){
ex.printStackTrace();
}
}
}
}
public void execute(){
for(String taskName : tasksCount.keySet()){
Integer taskCount = tasksCount.get(taskName);
for(int t = 0; t clazz = Class.forName(beanClassNames.get(taskName));
taskObj = context.getBean(clazz);
}
}
if(taskObj != null){
poolTaskExecutor.execute((Runnable) taskObj);
}
}catch(Exception ex){
ex.printStackTrace();
}
}
}
}
}
```
如何使用?(做事就要做全套 ^_^)1.因为使用的springboot项目,需要在application.properties 或者 application.yml 添加
```plain
#配置执行的task线程数
thread.count.NeedExcutorTask=4
#最大存活时间
thread.pool.aliveSec=300000
#其他配置同理
```
2.将我们写的线程配置进行装载到我们的项目中
```java
@Configuration
public class TaskManager {
@Resource
private TaskPool taskPool;
@PostConstruct
public void executor(){
taskPool.execute();
}
}
```
3.具体使用
```java
@ExcutorTask
public class NeedExcutorTask implements Runnable{
@Override
public void run() {
Thread.sleep(1000L);
log.info("====== 任务执行 =====")
}
}
```