java定时线程池源码分析

首先看个示例：

public class Test {
    public static void main(String[] args) {
        ScheduledExecutorService service = Executors.newScheduledThreadPool(10);
        service.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("-----schedule--------");
            }
        },2, TimeUnit.SECONDS);
        service.schedule(new Callable<Object>() {
            @Override
            public Object call() throws Exception {
                System.out.println("-----schedule--------");
                return "aaaaa";
            }
        },2, TimeUnit.SECONDS);
        service.scheduleWithFixedDelay(new Runnable() {
            @SneakyThrows
            @Override
            public void run() {
                Thread.sleep(5000);
                System.out.println("scheduleWithFixedDelay exectue  time =" + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
            }
        },2, 2,TimeUnit.SECONDS);
        service.scheduleAtFixedRate(new Runnable() {
            @SneakyThrows
            @Override
            public void run() {
                Thread.sleep(5000);
                System.out.println("scheduleAtFixedRate exectue  time =" + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
            }
        },2, 2,TimeUnit.SECONDS);
    }
}

 

scheduleWithFixedDelay和scheduleAtFixedRate区别

 如上述代码所述，scheduleWithFixedDelay和scheduleAtFixedRate都是延迟2s，按2s周期进行执行作业

第一次执行的时间是一致的，19:38:26  ，本来 两个作业下一次运行的时间 应该是  19:38:28，但是作业要执行5s，就会错过下一个运行的时间，这个区别就来了

scheduleAtFixedRate：错过了下一个运行的时间，执行完任务后，会立马执行，之后按周期5s来运行

scheduleWithFixedDelay：错过了下一个运行的时间，执行完任务后，仍然会延迟2s再运行，之后按周期7s来运行

scheduleAtFixedRate源码分析

    public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                                                  long initialDelay,
                                                  long period,
                                                  TimeUnit unit) {
        if (command == null || unit == null)
            throw new NullPointerException();
        if (period <= 0)
            throw new IllegalArgumentException();
        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;
    }

 ScheduledFutureTask 把runnable重新进行封装，设置一些属性

this.time = ns;
this.period = period;

triggerTime(initialDelay, unit) 计算出下一次将要运行的时间 this.time = ns;并赋值，之后做延迟工作排序要用到

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

这里跟其他内置线程池不一样，其他内置线程池，都是先要判断当前线程数是否小于核心线程数，这里直接入队

入队是一个核心方法：

        public boolean offer(Runnable x) {
            if (x == null)
                throw new NullPointerException();
            RunnableScheduledFuture<?> e = (RunnableScheduledFuture<?>)x;
            final ReentrantLock lock = this.lock;
            lock.lock();
            try {
                int i = size;
                if (i >= queue.length)
                    grow();
                size = i + 1;
                if (i == 0) {
                    queue[0] = e;
                    setIndex(e, 0);
                } else {
                    siftUp(i, e);
                }
                if (queue[0] == e) {
                    leader = null;
                    available.signal();
                }
            } finally {
                lock.unlock();
            }
            return true;
        }

这里用到ReentrantLock ，入队过程是线程安全的，当队列中一个任务都没有的时候，就直接插入，如果有多个元素就要执行siftUp方法，这个方法就是要保证队列中按下一次执行时间进行排序

        private void siftUp(int k, RunnableScheduledFuture<?> key) {
            while (k > 0) {
                int parent = (k - 1) >>> 1;
                RunnableScheduledFuture<?> e = queue[parent];
                if (key.compareTo(e) >= 0)
                    break;
                queue[k] = e;
                setIndex(e, k);
                k = parent;
            }
            queue[k] = key;
            setIndex(key, k);
        }

从代码上看，队列中按下一次运行时间排序，是不严格的排序，看一个示例：

public class Test {
    public static void main(String[] args) {
        ScheduledExecutorService service = Executors.newScheduledThreadPool(10);
        service.scheduleAtFixedRate(new Runnable() {
            @SneakyThrows
            @Override
            public void run() {
                Thread.sleep(5000);
                System.out.println("scheduleAtFixedRate exectue  time =" + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
            }
        },1, 1,TimeUnit.HOURS);
        service.scheduleAtFixedRate(new Runnable() {
            @SneakyThrows
            @Override
            public void run() {
                Thread.sleep(5000);
                System.out.println("scheduleAtFixedRate exectue  time =" + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
            }
        },2, 2,TimeUnit.HOURS);
        service.scheduleAtFixedRate(new Runnable() {
            @SneakyThrows
            @Override
            public void run() {
                Thread.sleep(5000);
                System.out.println("scheduleAtFixedRate exectue  time =" + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
            }
        },8, 8,TimeUnit.HOURS);
        service.scheduleAtFixedRate(new Runnable() {
            @SneakyThrows
            @Override
            public void run() {
                Thread.sleep(5000);
                System.out.println("scheduleAtFixedRate exectue  time =" + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
            }
        },2, 2,TimeUnit.HOURS);
    }
}

 index=3的时间小于index=2的时间，但是排在index=2的后面

入队之后：执行ensurePrestart();

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

 这里会计算当前线程是否小于核心线程数，如果小于，则创建核心线程，注意这里的firstTask=null,这个也跟其他的内置线程池不一样，其他的内置线程，第一次创建核心线程的时候，firstTask是不为空的

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

 接下来创建worker  w = new Worker(firstTask);

        Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
        }

利用getThreadFactory().newThread(this);创建一个线程，并把worker对象当作参数注入进去,因为work实现了Runnable接口

 知道这里为什么要继承AbstractQueuedSynchronizer，而且 setState(-1);因为在创建worker的过程中，不允许其他线程中断，中断程序需要获取到锁才能执行中断，看源码注解w.unlock(); // allow interrupts

然后就是执行worker  t.start();

        public void run() {
            runWorker(this);
        }

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

获取任务：task != null || (task = getTask()) != null

这个判断非常重要，因为定时线程池不一样，定时线程池的firstTask都是为null，所以task != null 为false ,所以需要重队列中取，执行getTask()

    private Runnable getTask() {
        boolean timedOut = false; // Did the last poll() time out?

        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }

            int wc = workerCountOf(c);

            // Are workers subject to culling?
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

            if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
                if (compareAndDecrementWorkerCount(c))
                    return null;
                continue;
            }

            try {
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;这个判断很重要，

由于定时器线程池不能更改allowCoreThreadTimeOut的值，默认为false,

要修改非要ThreadPoolExecutor service = (ThreadPoolExecutor) Executors.newScheduledThreadPool(2);这样声明，这样声明之后，不能使用定时器的方法

假设当前wc是10，corePoolSize为10，wc > corePoolSize此时这个明显也为false

则走workQueue.take();说明此时有10个线程在workQueue中的condition的条件队列中等待着

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

leader 是条件队头的那个线程，此时leader  available.awaitNanos(delay);是执行这个，再看下long delay = first.getDelay(NANOSECONDS);

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

这个就是延迟工作队列队头的那个任务距离下一次需要的时间，leader等到这个这个时间就会取获取队列的第一个元素，因为这个是for(;;)，重新执行RunnableScheduledFuture<?> first = queue[0];此时delay <= 0 为true， return finishPoll(first);

执行available.signal();唤醒条件队列中下一个堵塞的线程去执行，依次类推

这里说明了，只要allowCoreThreadTimeOut 为false, boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;timed=false,所以不管队列是否为空，还是达到了keepAliveTime，线程去队列取元素都是走

take()方法，没取到会进去条件队列堵塞，取到了执行作业，所以永远不会销毁

但是当allowCoreThreadTimeOut=true的时候，boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;timed=true，走的是 workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS)，poll是非堵塞方法，如果等到keepAliveTime没有取到元素，就会直接返回null，从而退出循环，从而run方法执行完，线程自然销毁，works（用hashset存放着）的数量remove此线程

假设当前wc是11，corePoolSize为10，wc > corePoolSize此时这个明显也为true

其实这步不存在，

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

因为在这步已经写死了，只能创建corePoolSize以内的线程数，但是在声明线程池的时候，又是说 最大线程树可以无限创建，有点矛盾呀？？？？？有木有大神发表下意见

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

当以上两步执行完，最后会执行

  private void processWorkerExit(Worker w, boolean completedAbruptly) {
        if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
            decrementWorkerCount();

        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            completedTaskCount += w.completedTasks;
            workers.remove(w);
        } finally {
            mainLock.unlock();
        }

        tryTerminate();

        int c = ctl.get();
        if (runStateLessThan(c, STOP)) {
            if (!completedAbruptly) {
                int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
                if (min == 0 && ! workQueue.isEmpty())
                    min = 1;
                if (workerCountOf(c) >= min)
                    return; // replacement not needed
            }
            addWorker(null, false);
        }
    }

这步就是让执行完任务的线程，自然销毁后，workers.remove(w);