踩了定时线程池的坑，导致公司损失几千万，血的教训

public class Demo {
    // 创建定时线程池
    private static ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);
    private List<String> partnerCache = new ArrayList<>();
    @PostConstruct
    public void init() {
        scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                // 启动时每隔60秒执行一次数据库的刷新
                // 将数据缓存至本地
                loadPartner();
            }
        }, 3, 60, TimeUnit.SECONDS);
    }
    public void loadPartner() {
        // 查询数据库当前最新合作方数据
        List<String> partnerList = queryPartners();
        // 合作方数据放至缓存
        partnerCache.clear();
        partnerCache.addAll(partnerList);
    }
    public List<String> queryPartners() {
        // 数据库挂了！
        throw new RuntimeException();
    }
}

class MyDelayedTask implements Delayed{
    // 当前任务创建时间
    private long start = System.currentTimeMillis();
    // 延时时间
    private long time ;
    // 初始化
    public MyDelayedTask(long time) {
        this.time = time;
    }
    /**
     * 需要实现的接口，获得延迟时间（用过期时间-当前时间）
     */
    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert((start+time) - System.currentTimeMillis(),TimeUnit.MILLISECONDS);
    }
    /**
     * 用于延迟队列内部比较排序（当前时间的延迟时间 - 比较对象的延迟时间）
     */
    @Override
    public int compareTo(Delayed o) {
        MyDelayedTask o1 = (MyDelayedTask) o;
        return (int) (this.getDelay(TimeUnit.MILLISECONDS) - o.getDelay(TimeUnit.MILLISECONDS));
    }
}

public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) {
    // 初始化我们的任务
    // triggerTime：延时的实现
    ScheduledFutureTask<Void> sft = new ScheduledFutureTask<Void>(command,null,triggerTime(initialDelay, unit),unit.toNanos(period));
    RunnableScheduledFuture<Void> t = decorateTask(command, sft);
    sft.outerTask = t;
    delayedExecute(t);
    return t;
}
private void delayedExecute(RunnableScheduledFuture<?> task) {
    // 将当前任务丢进延时队列
    super.getQueue().add(task);
    // 创建核心线程并启动 
    ensurePrestart();
}
// 时间轮算法
private long triggerTime(long delay, TimeUnit unit) {
    return now() + delay;
}

for (;;) {
    // 从延时队列中获取任务
    Runnable r = workQueue.take();
}
public RunnableScheduledFuture<?> take(){
    for (;;) {
        // 获取队列第一个任务
        RunnableScheduledFuture<?> first = queue[0];
        // 【重点】如果当前队列任务为空，则等待
        if (first == null){
            available.await();
        }
        // 获取当前任务的时间
        long delay = first.getDelay(NANOSECONDS);
        if (delay <= 0){
            // 弹出当前任务
            return finishPoll(first);
        }
    }
}
// 时间戳减去当前时间
public long getDelay(TimeUnit unit) {
    return unit.convert(time - now(), NANOSECONDS);
}

public void run() {
   // 执行当前的任务
   if (ScheduledFutureTask.super.runAndReset()) {
        setNextRunTime();
        reExecutePeriodic(outerTask);
    }
}
protected boolean runAndReset() {
    if (state != NEW){
        return false;
    }
    int s = state;
    try {
        Callable<V> c = callable;
        if (c != null && s == NEW) {
            try {
                // 执行任务
                c.call(); 
                // 【重点！！！】如果任务正常执行成功的话,这里会将ran置为true
                // 如果你的任务有问题,会被下面直接捕捉到,不会将此处的ran置为true
                ran = true;
            } catch (Throwable ex) {
                // 出现异常会将state置为EXCEPTIONAL
                // 标记当前任务执行失败并将异常赋值到结果
                setException(ex);
            }finally {
                 s = state;
            }
        }
    }
    // ran：当前任务是否执行成功
    // s：当前任务状态
    // ran为false：当前任务执行失败
    // s == NEW = false：当前任务状态出现异常
    return ran && s == NEW;
}

if (ScheduledFutureTask.super.runAndReset()) {
    // 修改当前任务的Time
    setNextRunTime();
    // 将任务重新丢进队列
    reExecutePeriodic(outerTask);
}