scheduleWithFixedDelay源码解析，简单粗暴了解基本原理

ScheduledExecutorService.scheduleWithFixedDelay方法可以延时循环完成某些特定的任务

使用方式

        使用时传入4个参数，command执行的任务Runable方法，initialDelay-初始延时时间，delay-每次执行任务的间隔时间，unit-单位

使用注意事项，执行的方法需要try catch。不然报错了就不会继续往下执行了。

    public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = new ScheduledThreadPoolExecutor(1,
                new BasicThreadFactory.Builder().namingPattern("ik-mysql-schedule-pool-%d").build());
        scheduledExecutorService.scheduleWithFixedDelay(() -> {
            System.out.println("执行任务");
        }, 1000,1000, TimeUnit.MILLISECONDS);
    }

源码

        这里我们使用的是ScheduledThreadPoolExecutor ,所以直接进去看他的scheduleWithFixedDelay方法

    public ScheduledFuture scheduleWithFixedDelay(Runnable command,
                                                     long initialDelay,
                                                     long delay,
                                                     TimeUnit unit) {
        if (command == null || unit == null)
            throw new NullPointerException();
        if (delay <= 0)
            throw new IllegalArgumentException();
        //创建任务
        ScheduledFutureTask sft =
            new ScheduledFutureTask(command,
                                          null,
                                          triggerTime(initialDelay, unit),
                                          unit.toNanos(-delay));
        RunnableScheduledFuture t = decorateTask(command, sft);
        sft.outerTask = t;
        //开始执行
        delayedExecute(t);
        return t;
    }

        这里我们传入的任务通过ScheduledFutureTask封装了一下。这里可以先不进去看，先继续往下。进入delayedExecute方法。

        这个方法先将任务添加到延时队列中，然后执行。

    private void delayedExecute(RunnableScheduledFuture task) {
        if (isShutdown())
            reject(task);
        else {
            //将任务添加至延时队列中
            super.getQueue().add(task);
            if (isShutdown() &&
                !canRunInCurrentRunState(task.isPeriodic()) &&
                remove(task))
                task.cancel(false);
            else
                //继续执行方法
                ensurePrestart();
        }
    }

        这里的workqueue就是一个延时队列，我们在创建线程池的时候初始化的 ，这里先有个概念，后面会说到

    public ScheduledThreadPoolExecutor(int corePoolSize,
                                       ThreadFactory threadFactory) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue(), threadFactory);
    }

        继续进入ensurePrestart方法，这个方法就是保证至少有一条线程执行，每个线程创建一个worker，这里我们叫他干活的，这个方法也比较容易读懂，当小于核心线程数的时候就添加一个worker，比如我们创建线程池的时候核心线程数是1，那么这里就只有1个干活的，如果是2那就是2个。

    void ensurePrestart() {
        int wc = workerCountOf(ctl.get());
        if (wc < corePoolSize)
            addWorker(null, true);
        else if (wc == 0)
            addWorker(null, false);
    }

        进入addWorker方法，这里我们可以看到全面做了一些判断比如队列里没有数据啊之类的就返回false，着重关注newWoker();

private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            for (;;) {
                int wc = workerCountOf(c);
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                c = ctl.get();  // Re-read ctl
                if (runStateOf(c) != rs)
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
            }
        }

        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    // Recheck while holding lock.
                    // Back out on ThreadFactory failure or if
                    // shut down before lock acquired.
                    int rs = runStateOf(ctl.get());

                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                        workers.add(w);
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

        这里创建了一个干活的，然后通过t.start()开启了线程，worker实现了runable，那么这里就会执行他的run方法，run方法又调用了runWorker

        runWoker里面则是通过一个无限循环不断的通过getTask()去拿任务，然后执行。

final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            while (task != null || (task = getTask()) != null) {
                w.lock();
                // If pool is stopping, ensure thread is interrupted;
                // if not, ensure thread is not interrupted.  This
                // requires a recheck in second case to deal with
                // shutdownNow race while clearing interrupt
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        task.run();
                    } catch (RuntimeException x) {
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

        拿到这个任务之后当然是调用这个任务的run方法执行任务，这里的任务就是之前封装的ScheduledFutureTask，那么就来看看里面的run方法干了什么。

         有点类似于递归，先通过runAndReset执行我们自己的方法，然后通过reExecutePeriodic方法继续往延时队列中添加任务，这边使劲添加，然后worker就疯狂干活。

        public void run() {
            boolean periodic = isPeriodic();
            if (!canRunInCurrentRunState(periodic))
                cancel(false);
            else if (!periodic)
                //如果不是延时，则只执行一次
                ScheduledFutureTask.super.run();
            else if (ScheduledFutureTask.super.runAndReset()) {
                //设置下一次执行的时间
                setNextRunTime();
                //继续往延时队列中添加当前任务，outerTask=this
                reExecutePeriodic(outerTask);
            }
        }

        了解了它的循环机制，那么他又是怎么实现间隔时间的机制呢？

        答案需要从延时队列中去寻找，我们之前说过worker会无限的从延时队列里面去获取任务，通过workQueue.take();从延时队列里面拿任务，那么我们看看延时队列DelayedWorkQueue里的take方法。

        这里first就是我们封装的Runable,然后通过getDelay方法获取延时时间，awaitNanos就是让线程挂起，这里的awaitNanos其实就是ConditionObject中的awaitNanos方法，通过LockSupport.parkNanos(this, nanosTimeout);来使线程挂起，从而达到延时的效果。

public RunnableScheduledFuture take() throws InterruptedException {
            final ReentrantLock lock = this.lock;
            lock.lockInterruptibly();
            try {
                for (;;) {
                    RunnableScheduledFuture first = queue[0];
                    if (first == null)
                        available.await();
                    else {
                        //获取延时时间，里面方法是延时的最终时间-当前时间
                        long delay = first.getDelay(NANOSECONDS);
                   
                        if (delay <= 0)
                            //达到了延时最终时间，则取出来返回
                            return finishPoll(first);
                        first = null; // don't retain ref while waiting
                        if (leader != null)
                            available.await();
                        else {
                            Thread thisThread = Thread.currentThread();
                            leader = thisThread;
                            try {
                                //没有到达预期的时间，则继续挂起线程
                                available.awaitNanos(delay);
                            } finally {
                                if (leader == thisThread)
                                    leader = null;
                            }
                        }
                    }
                }
            } finally {
                if (leader == null && queue[0] != null)
                    available.signal();
                lock.unlock();
            }
        }

       getDelay方法就是获取延时时间，这里我们结合之前那个递归的setNextRunTime来看，就一目了然了，每次执行过后会调用setNextRunTime,time往上加period的时间，period就是我们设置的延时时间，然后每次延时队列take的时候又会先把线程阻塞time - now的时间（参考延时队列的take方法）。

       public long getDelay(TimeUnit unit) {
            return unit.convert(time - now(), NANOSECONDS);
        }



        private void setNextRunTime() {
            long p = period;
            if (p > 0)
                time += p;
            else
                time = triggerTime(-p);
        }

        总结

       当系统需要循环间隔一定时间执行某项任务的时候可以使用scheduleWithFixedDelay方法来实现。

        实现大致分为3个角色，任务（ScheduleFutureTask），队列（DelayedWorkQueue），工人(Worker)。调用scheduleFixedDelay方法之后，会创建ScheduleFutureTask，然后会根据核心线程数创建对应的Worker，Worker负责从延时队列中获取Task拿任务然后执行。Task任务执行完之后会再往延迟队列中添加当前任务， 以此实现循环机制。延迟队列的take方法中会有一个getDelay，获取任务的时候会先将线程挂起设置的间隔时间，以此实现间隔机制

        1.创建线程池，队列采用延时队列

        2.通过woker不断的从延时队列中拿任务来执行，worker数量由核心线程数决定

        3.循环机制是通过封装的ScheduledFutureTask里面的run方法实现，原理是每次执行完之后，先设置延时最终时间，然后再往队列里继续添加任务，达到无限循环的效果。

        4.间隔机制是通过延时队列中的take方法实现，原理是，每次取的时候会先判断是否达到延时最终时间，如果没有达到则挂起线程，达到了才获取任务执行。阻塞时间即为设置的间隔时间