ScheduledThreadPoolExecutor详解

ScheduledThreadPoolExecutor继承自ThreadPoolExecutor。它主要用来在给定的延迟之后运行任务，或者定期执行任务。ScheduledThreadPoolExecutor可以在构造函数中指定多个对应的后台线程数。

ScheduledThreadPoolExecutor的运行机制

ScheduledThreadPoolExecutor的任务传递示意图

DelayQueue是一个无界队列，所以ThreadPoolExecutor的maximumPoolSize在ScheduledThreadPoolExecutor中没有什么意义（设置maximumPoolSize的大小没有效果）。

ScheduledThreadPoolExecutor的执行主要分为两大部分。

1. 当调用ScheduledThreadPoolExecutor的scheduleAtFixedRate()方法或者scheduleWithFixedDelay()方法时，会向ScheduledThreadPoolExecutor的DelayQueue添加一个实现了RunnableScheduledFuture接口的ScheduledFutureTask。
2. 线程池中的线程从DelayQueue中获取ScheduledFutureTask，然后执行任务。

ScheduledThreadPoolExecutor的实现

ScheduledThreadPoolExecutor会把待调度的任务（ScheduledFutureTask）放到一个DelayQueue中。

ScheduledFutureTask主要包含3个成员变量：

• long型成员变量time，表示这个任务将要被执行的具体时间。
• long型成员变量sequenceNumber，表示这个任务被添加到ScheduledThreadPoolExecutor中的序号。
• long型成员变量period，表示任务执行的间隔周期。

DelayQueue封装了一个PriorityQueue，这个PriorityQueue会对队列中的ScheduledFutureTask进行排序。排序时，time小的排在前面（时间早的任务将被先执行）。如果两个ScheduledFutureTask的time相同，就比较sequenceNumber，sequenceNumner小的排在前面（也就是说，如果两个任务的执行时间相同，那么先提交的任务将被先执行）。

ScheduledThreadPoolExecutor的任务执行步骤

1. 线程1从DelayQueue中获取已到期的ScheduledFutureTask(DelayQueue.take())。到期任务是指ScheduledFutureTask的time大于等于当前时间。
2. 线程1执行这个ScheduledFutureTask。
3. 线程1修改ScheduledFutureTask的time变量为下次将要被执行的时间。
4. 线程1把这个修改time之后的ScheduledFutureTaks放回DelayQueue中(DelayQueue.add())。

源码实现：

public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly(); 
    try {
        for (;;) {
            E first = q.peek();
            if (first == null)
                available.await(); 
            else {
                long delay = first.getDelay(NANOSECONDS);
                if (delay <= 0)
                    return q.poll();
                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 && q.peek() != null)
            available.signal();
        lock.unlock(); 
    }
}

获取任务分为3大步骤：

1. 获取Lock。
2. 获取周期任务。
   • 如果PriorityQueue为空，当前线程到Condition中等待；否则执行下一步。
   • 如果PriorityQueue的头元素的time时间比当前时间大，到Condition中等待time时间；否则执行下一步。
   • 获取PriorityQueue头元素；如果PriorityQueue不为空，则唤醒在Condition中等待的所有线程。
3. 释放Lock。

ScheduledThreadPoolExecutor在一个循环中执行步骤2，直到线程从PriorityQueue获取一个元素，才会退出无限循环。

ScheduledThreadPoolExecutor执行任务之后，把ScheduledFutureTaks放回DelayQueue中的过程，以下为DelayQueue.add()源码实现：

public boolean add(E e) {
    return offer(e);
}

public boolean offer(E e) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        q.offer(e);
        if (q.peek() == e) {
            leader = null;
            available.signal();
        }
        return true;
    } finally {
        lock.unlock();
    }
}

添加任务分为3大步骤：

1. 获取Lock。
2. 添加任务。
   • 向PriorityQueue添加任务。
   • 如果添加的任务是PriorityQueue的头元素，唤醒在Condition中等待的所有线程。
3. 释放Lock。