线程池包装类
package com.example.git_lab_exc.service;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import javax.lang.model.element.VariableElement;
import org.springframework.stereotype.Service;
/**
* @auther lpc
* @create 2022-05-25-16:45
*/
@Service
public class DelayExcetor implements DelayService {
ExecutorService executorService = new ThreadPoolExecutor(3, 4, 1
, TimeUnit.MINUTES, new LinkedBlockingQueue<>(32), new MyThreadFactory("延迟线程"),
RejectHandlerGetter.getProxy(RejectedTypeEnum.ABORT_POLICY.getName()));
public static ThreadLocal<Object> localMap = new InheritableThreadLocal<>();
@Override
public void excute(long time, TimeUnit timeUnit) {
DelayDto delayDto = new DelayDto(time, timeUnit);
localMap.set(delayDto);
DelayedTask delayedTask = new DelayedTask();
delayedTask.setParam(time, timeUnit);
executorService.execute(delayedTask);
System.out.println("主线程执行");
}
}
任务实现类与线程
package com.example.git_lab_exc.service;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;
import javax.annotation.PostConstruct;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.stereotype.Component;
/**
* @auther lpc
* @create 2022-05-25-16:41
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@Component
public class DelayedTask implements Delayed, Runnable {
private long start = System.currentTimeMillis();
private long time;
private TimeUnit timeUnit;
public void setParam(long time, TimeUnit timeUnit) {
this.time = time;
this.timeUnit = timeUnit;
}
@Override
public long getDelay(TimeUnit timeUnit) {
return timeUnit.convert((start + time) - System.currentTimeMillis(), timeUnit);
}
public DelayedTask(long time, TimeUnit timeUnit) {
this.time = time;
this.timeUnit = timeUnit;
}
@Override
public int compareTo(Delayed o) {
DelayedTask o1 = (DelayedTask) o;
return (int) (this.getDelay(TimeUnit.MILLISECONDS) - o1.getDelay(TimeUnit.MILLISECONDS));
}
@Override
public void run() {
DelayQueue<Delayed> delayeds = new DelayQueue<>();
DelayDto o = (DelayDto)DelayExcetor.localMap.get();
long time = o.getTime();
TimeUnit timeUnit = o.getTimeUnit();
DelayedTask e1 = new DelayedTask(time, timeUnit);
delayeds.offer(e1);
try {
delayeds.take();
// TODO: 2022/5/25 业务逻辑
System.out.println("延迟的业务逻辑");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
线程池拒绝策略代理类
package com.example.git_lab_exc.service;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.concurrent.ThreadPoolExecutor;
/**
* @auther lpc
* @create 2022-05-12-10:56
*/
public class RejectHandler implements InvocationHandler {
private final Object target;
public RejectHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
Runnable r = (Runnable) args[0];
ThreadPoolExecutor executor = (ThreadPoolExecutor) args[1];
beforeReject(executor, r);
return method.invoke(target, args);
} catch (InvocationTargetException ex) {
throw ex.getCause();
}
}
private void beforeReject(ThreadPoolExecutor executor, Runnable r) {
System.out.println("拒绝前代理操作");
}
}
线程池拒绝策略获得类
package com.example.git_lab_exc.service;
import java.lang.reflect.Proxy;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
import java.util.ServiceLoader;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationContext;
/**
*
* @author lpc
* @date 2022/5/9
**/
@Slf4j
public class RejectHandlerGetter {
private RejectHandlerGetter() {
}
public static RejectedExecutionHandler buildRejectedHandler(String name) {
if (Objects.equals(name, RejectedTypeEnum.ABORT_POLICY.getName())) {
// jdk 默认方式-->抛异常方式处理
return new ThreadPoolExecutor.AbortPolicy();
} else if (Objects.equals(name, RejectedTypeEnum.CALLER_RUNS_POLICY.getName())) {
// 由调用方自己处理
return new ThreadPoolExecutor.CallerRunsPolicy();
} else if (Objects.equals(name, RejectedTypeEnum.DISCARD_OLDEST_POLICY.getName())) {
// 丢弃queue 头部任务,将新任务插入queue 尾部
return new ThreadPoolExecutor.DiscardOldestPolicy();
} else if (Objects.equals(name, RejectedTypeEnum.DISCARD_POLICY.getName())) {
// 直接丢弃
return new ThreadPoolExecutor.DiscardPolicy();
}
return new ThreadPoolExecutor.DiscardPolicy();
}
public static RejectedExecutionHandler getProxy(String name) {
return getProxy(buildRejectedHandler(name));
}
public static RejectedExecutionHandler getProxy(RejectedExecutionHandler handler) {
return (RejectedExecutionHandler) Proxy
.newProxyInstance(handler.getClass().getClassLoader(),
new Class[]{RejectedExecutionHandler.class},
new RejectHandler(handler));
}
}
线程池拒绝策略枚举类
package com.example.git_lab_exc.service;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
/**
* RejectedTypeEnum related
*
* @author lpc
* @date 2022/5/9
**/
@Slf4j
@Getter
public enum RejectedTypeEnum {
/**
* RejectedExecutionHandler type while triggering reject policy.
*/
ABORT_POLICY("AbortPolicy"),
CALLER_RUNS_POLICY("CallerRunsPolicy"),
DISCARD_OLDEST_POLICY("DiscardOldestPolicy"),
DISCARD_POLICY("DiscardPolicy"),
BLOCK_WHEN_QUEUE_FULL("BlockWhenQueueFull");
private final String name;
RejectedTypeEnum(String name) {
this.name = name;
}
}