利用InheritableThreadLocal进行子父线程参数传递

线程池包装类

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;
    }
}