private class ScheduledFutureTask<V> extends FutureTask<V> implements RunnableScheduledFuture<V> {
    ...
}

public interface RunnableScheduledFuture<V> extends RunnableFuture<V>, ScheduledFuture<V> {

    /**
     * Returns true if this is a periodic task. A periodic task may
     * re-run according to some schedule. A non-periodic task can be
     * run only once.
     *
     * @return true if this task is periodic
     */
    boolean isPeriodic();
}

public interface ScheduledFuture<V> extends Delayed, Future<V> {
}

public interface Delayed extends Comparable<Delayed> {

    /**
     * Returns the remaining delay associated with this object, in the
     * given time unit.
     *
     * @param unit the time unit
     * @return the remaining delay; zero or negative values indicate
     * that the delay has already elapsed
     */
    long getDelay(TimeUnit unit);
}

/**
 * Sequence number to break ties FIFO
 * 任务在队列中的序号
 * */
private final long sequenceNumber;

/**
 * The time the task is enabled to execute in nanoTime units
 * 任务应该执行的时间，以纳秒计算
 * */
private long time;

/**
 * Period in nanoseconds for repeating tasks.  A positive
 * value indicates fixed-rate execution.  A negative value
 * indicates fixed-delay execution.  A value of 0 indicates a
 * non-repeating task.
 *
 * 任务重复执行的时间间隔，以纳秒计算
 * 当其为正值时，表示固定速率执行
 * 当其为负值时，表示固定延迟执行
 * 当其为0时，表示是非重复任务
 */
private final long period;

/** The actual task to be re-enqueued by reExecutePeriodic */
RunnableScheduledFuture<V> outerTask = this;

/**
 * Index into delay queue, to support faster cancellation.
 */
int heapIndex;

/**
 * Creates a one-shot action with given nanoTime-based trigger time.
 * 根据给定开始时间，创建仅执行一次的任务
 */
ScheduledFutureTask(Runnable r, V result, long ns) {
    super(r, result);
    this.time = ns;
    this.period = 0;
    this.sequenceNumber = sequencer.getAndIncrement();
}

/**
 * Creates a periodic action with given nano time and period.
 * 根据给定开始时间和间隔时间，创建周期性任务
 */
ScheduledFutureTask(Runnable r, V result, long ns, long period) {
    super(r, result);
    this.time = ns;
    this.period = period;
    this.sequenceNumber = sequencer.getAndIncrement();
}

/**
 * Creates a one-shot action with given nanoTime-based trigger.
 * 根据给定开始时间，创建仅执行一次的任务
 */
ScheduledFutureTask(Callable<V> callable, long ns) {
    super(callable);
    this.time = ns;
    this.period = 0;
    this.sequenceNumber = sequencer.getAndIncrement();
}

private static final AtomicLong sequencer = new AtomicLong(0);

// 获取ScheduledFutureTask任务剩余的延迟时间
public long getDelay(TimeUnit unit) {
    return unit.convert(time - now(), TimeUnit.NANOSECONDS);
}

/**
 * Returns current nanosecond time.
 * 返回当前纳秒时间
 */
final long now() {
    return System.nanoTime();
}

/**
* Sets the next time to run for a periodic task.
* 设置下一次执行时间
*/
private void setNextRunTime() {
    // 获取周期时间间隔
    long p = period;
    if (p > 0)
    /**
    * 如果p大于0，表示是周期性执行任务，
    * 下一次执行任务在本次任务的period时间段后
    */
        time += p;
    else
    /**
    * 如果p小于0，表示是间隔性执行任务
    * 使用triggerTime()计算下一次执行任务的时间
    */
        time = triggerTime(-p);
}

/**
 * Returns the trigger time of a delayed action.
 * 根据传入的延迟时间和当前时间，计算最终触发时间
 */
long triggerTime(long delay) {
    /**
     * 延迟时间delay小于Long.MAX_VALUE >> 1，则返回now() + delay
     * 延迟时间delay大于Long.MAX_VALUE >> 1，则返回overflowFree()处理的结果，处理过程详见该方法
     */
    return now() + ((delay < (Long.MAX_VALUE >> 1)) ? delay : overflowFree(delay));
}

/**
 * Constrains the values of all delays in the queue to be within
 * Long.MAX_VALUE of each other, to avoid overflow in compareTo.
 * This may occur if a task is eligible to be dequeued, but has
 * not yet been, while some other task is added with a delay of
 * Long.MAX_VALUE.
 */
private long overflowFree(long delay) {
    // 查看延迟等待队列（在ScheduledThreadPoolExecutor中使用的是延迟队列DelayedWorkQueue）中的队首任务
    Delayed head = (Delayed) super.getQueue().peek();
    if (head != null) {
        // 如果队首任务不为null，计算队首任务相对于当前时间还需要延迟的时间headDelay
        long headDelay = head.getDelay(TimeUnit.NANOSECONDS);
        /**
         * 如果headDelay小于0，表示此时队首任务应该出队了，但恰好有任务入队
         * 且delay - headDelay小于0，则表示此时delay的值小于0或大于Long.MAX_VALUE
         * 而传入该方法的delay一定是大于0的，因此此时delay大于Long.MAX_VALUE
         */
        if (headDelay < 0 && (delay - headDelay < 0))
        /**
         * 如果delay大于Long.MAX_VALUE，且队首任务应该要出队了（headDelay为负）
         * 则将delay置为Long.MAX_VALUE + headDelay
         */
            delay = Long.MAX_VALUE + headDelay;
    }
    // 返回delay
    return delay;
}

/**
 * Returns true if this is a periodic (not a one-shot) action.
 *
 * 判断是否是周期性任务
 *
 * @return true if periodic
 */
public boolean isPeriodic() {
    return period != 0;
}

/**
 * 与其他ScheduledFutureTask任务进行比较
 * 主要通过time成员变量来比较
 */
public int compareTo(Delayed other) {
    // 判断二者是否是同一个对象，如果是则返回0
    if (other == this) // compare zero ONLY if same object
        return 0;
    // 判断传入的other对象是否是ScheduledFutureTask类型
    if (other instanceof ScheduledFutureTask) {
        // 强转
        ScheduledFutureTask<?> x = (ScheduledFutureTask<?>)other;
        // 计算二者时间差
        long diff = time - x.time;
        // 当前任务在other任务之前执行
        if (diff < 0)
            return -1;
        // 当前任务在other任务之后执行
        else if (diff > 0)
            return 1;
        // 如果两个任务的执行时间相同则比较序号
        else if (sequenceNumber < x.sequenceNumber)
        /**
         * 当前任务与other任务执行时间相同，但序号较小
         * 因此当前任务先执行
         */
            return -1;
        else
        /**
         * 当前任务与other任务执行时间相同，但序号较大
         * 因此当前任务后执行
         */
            return 1;
    }
    /**
     * 走到这里表示传入的other不是ScheduledFutureTask类型
     * 计算二者的执行时间差，根据该差值决定大小
     */
    long d = (getDelay(TimeUnit.NANOSECONDS) - other.getDelay(TimeUnit.NANOSECONDS));
    return (d == 0) ? 0 : ((d < 0) ? -1 : 1);
}

/**
 * Specialized delay queue. To mesh with TPE declarations, this
 * class must be declared as a BlockingQueue<Runnable> even though
 * it can only hold RunnableScheduledFutures.
 * 延时队列，用于装载被执行的任务，然后根据调度配置进行入队和出队操作
 * 小顶堆模式实现
 */
static class DelayedWorkQueue extends AbstractQueue<Runnable> implements BlockingQueue<Runnable> {
    ...
}

// 初始容量为16
private static final int INITIAL_CAPACITY = 16;
// 用于装载任务的数组
private RunnableScheduledFuture[] queue = new RunnableScheduledFuture[INITIAL_CAPACITY];
// 锁
private final ReentrantLock lock = new ReentrantLock();
// 大小
private int size = 0;

/**
 * Thread designated to wait for the task at the head of the
 * queue.  This variant of the Leader-Follower pattern
 * (http://www.cs.wustl.edu/~schmidt/POSA/POSA2/) serves to
 * minimize unnecessary timed waiting.  When a thread becomes
 * the leader, it waits only for the next delay to elapse, but
 * other threads await indefinitely.  The leader thread must
 * signal some other thread before returning from take() or
 * poll(...), unless some other thread becomes leader in the
 * interim.  Whenever the head of the queue is replaced with a
 * task with an earlier expiration time, the leader field is
 * invalidated by being reset to null, and some waiting
 * thread, but not necessarily the current leader, is
 * signalled.  So waiting threads must be prepared to acquire
 * and lose leadership while waiting.
 * 
 * 试图执行队首任务的正处于等待状态的线程对象
 */
private Thread leader = null;

/**
 * Condition signalled when a newer task becomes available at the
 * head of the queue or a new thread may need to become leader.
 * 等待条件
 */
private final Condition available = lock.newCondition();

/**
 * Find index of given object, or -1 if absent
 * 查找给定x在数组中的索引
 */
private int indexOf(Object x) {
    // x不能为null
    if (x != null) {
        // x要是ScheduledFutureTask类型的对象
        if (x instanceof ScheduledFutureTask) {
            // 获取x的heapIndex为i
            int i = ((ScheduledFutureTask) x).heapIndex;
            // Sanity check; x could conceivably be a
            // ScheduledFutureTask from some other pool.
            // 如果i大于等于0，且i小于size，且queue中i位置的任务与x相等
            if (i >= 0 && i < size && queue[i] == x)
                // i即是x在数组中的索引，直接返回
                return i;
        } else {
            /**
             * 如果x不是ScheduledFutureTask对象
             * 遍历queue数组，依次查找
             */
            for (int i = 0; i < size; i++)
                // 当查找到的任务与x相同，则返回此时的索引i
                if (x.equals(queue[i]))
                    return i;
        }
    }
    // 否则返回-1，表示没找到
    return -1;
}

// 判断任务x是否存在于queue中
public boolean contains(Object x) {
    // 加锁
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        // 使用indexOf()进行查找并判断
        return indexOf(x) != -1;
    } finally {
        // 解锁
        lock.unlock();
    }
}

// 队列是否为空
public boolean isEmpty() {
    return size() == 0;
}

// 查看队列大小
public int size() {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        // 直接返回size即可
        return size;
    } finally {
        lock.unlock();
    }
}

/**
 * Resize the heap array.  Call only when holding lock.
 * 扩容操作
 */
private void grow() {
    // 旧的容量
    int oldCapacity = queue.length;
    // 新的容量是旧的容量的1.5倍
    int newCapacity = oldCapacity + (oldCapacity >> 1); // grow 50%
    // 如果溢出就将其设置为Integer.MAX_VALUE
    if (newCapacity < 0) // overflow
        newCapacity = Integer.MAX_VALUE;
    // 拷贝旧数组的任务到新数组，然后将新数组赋值给queue
    queue = Arrays.copyOf(queue, newCapacity);
}

// 剩余容量是无限的
public int remainingCapacity() {
    return Integer.MAX_VALUE;
}

// 添加任务，内部调用offer()
public void put(Runnable e) {
    offer(e);
}

// 添加任务，内部调用offer()
public boolean add(Runnable e) {
    return offer(e);
}

// 添加任务，内部调用offer()
public boolean offer(Runnable e, long timeout, TimeUnit unit) {
    return offer(e);
}

// 添加任务
public boolean offer(Runnable x) {
    // 检查任务
    if (x == null)
        throw new NullPointerException();
    //将任务转换为RunnableScheduledFuture对象
    RunnableScheduledFuture e = (RunnableScheduledFuture)x;
    // 加锁
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        int i = size;
        if (i >= queue.length)
            // 如果任务个数大于等于队列数组容量，进行扩容操作
            grow();
        // size加1
        size = i + 1;
        if (i == 0) {
            /**
             * i为0，即原始size为0，没有任务
             * 将e放在第0位置
             */
            queue[0] = e;
            // 设置e的heapIndex为0
            setIndex(e, 0);
        } else {
            // 否则调用siftUp()对e进行添加及上浮操作
            siftUp(i, e);
        }
        /**
         * 如果第0个位置的任务是e，
         * 表示此时入队的是队首元素，可以将leader清空了
         * 同时可以通知其他线程可以竞争成为leader了
         */
        if (queue[0] == e) {
            // 将leader置为null
            leader = null;
            // 唤醒等待在available上的线程
            available.signal();
        }
    } finally {
        // 解锁
        lock.unlock();
    }
    return true;
}

/**
 * Set f's heapIndex if it is a ScheduledFutureTask.
 * 设置ScheduledFutureTask的heapIndex
 */
private void setIndex(RunnableScheduledFuture f, int idx) {
    // 当传入的f是ScheduledFutureTask类型时，设置其heapIndex
    if (f instanceof ScheduledFutureTask)
        ((ScheduledFutureTask)f).heapIndex = idx;
}

/**
 * Sift element added at bottom up to its heap-ordered spot.
 * Call only when holding lock.
 * 堆上浮操作
 * @param k 添加之前的数组大小
 * @param key 添加的任务
 */
private void siftUp(int k, RunnableScheduledFuture key) {
    // 循环直到k为0
    while (k > 0) {
        // 获取k位置任务的父任务的索引
        int parent = (k - 1) >>> 1;
        // 取出父任务
        RunnableScheduledFuture e = queue[parent];
        /**
         * 将key与父任务进行比较，如果key大于等于父任务，
         * 表示key要在父任务之后或者与父任务同时执行，则跳出循环
         */
        if (key.compareTo(e) >= 0)
            break;
        /**
         * 否则key小于父任务，表示key要比父任务早执行
         * 因此将k位置替换为父任务
         */
        queue[k] = e;
        // 修改父任务的heapIndex为k
        setIndex(e, k);
        // 将父任务索引赋值给k，进行下一次循环
        k = parent;
    }
    /**
     * 走到这里说明key要在父任务之后或者与父任务同时执行
     * 则已经找到了key所应该在的位置
     * 将key放在k索引位置
     */
    queue[k] = key;
    // 将key的heapIndex设置为k
    setIndex(key, k);
}

// 取出队首任务
public RunnableScheduledFuture poll() {
    // 加锁
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        // 获取queue索引为0位置的任务为first
        RunnableScheduledFuture first = queue[0];
        // 如果first任务为null，或者first任务的延迟时间还大于0，就返回null
        if (first == null || first.getDelay(TimeUnit.NANOSECONDS) > 0)
            return null;
        else
            // 否则调用finishPoll()将first返回，并对堆进行调整
            return finishPoll(first);
    } finally {
        // 解锁
        lock.unlock();
    }
}

/**
 * Performs common bookkeeping for poll and take: Replaces
 * first element with last and sifts it down.  Call only when
 * holding lock.
 * 将第一个任务与最后一个任务进行替换，然后进行下沉操作
 * @param f the task to remove and return
 */
private RunnableScheduledFuture finishPoll(RunnableScheduledFuture f) {
    int s = --size;
    // 取出最后一个任务为x
    RunnableScheduledFuture x = queue[s];
    // 将最后索引位置上置为null
    queue[s] = null;
    // 如果最后索引不是0，表示堆中元素个数大于1
    if (s != 0)
        // 将x从堆顶开始做下沉操作
        siftDown(0, x);
    // 设置f的heapIndex为-1，并将其返回
    setIndex(f, -1);
    return f;
}

/**
 * Sift element added at top down to its heap-ordered spot.
 * Call only when holding lock.
 * 堆下沉操作
 */
private void siftDown(int k, RunnableScheduledFuture key) {
    // 取数组queue中心位置索引half
    int half = size >>> 1;
    /**
     * 循环直到k大于或等于中心索引half时，
     * 由于从half开始，节点就不再有孩子节点
     */
    while (k < half) {
        // 获取左孩子节点的索引
        int child = (k << 1) + 1;
        // 获取左孩子节点
        RunnableScheduledFuture c = queue[child];
        // 获取右孩子节点的索引
        int right = child + 1;
        /**
         * 当右孩子节点的索引小于size时，说明右孩子还存在
         * 比较左孩子与右孩子的大小
         * 如果左孩子比右孩子大，表明右孩子比左孩子的任务更早执行
         * 则将c指向右孩子，child指向right索引
         * 此时c指向的是更早执行的任务所在的那个孩子节点
         */
        if (right < size && c.compareTo(queue[right]) > 0)
            c = queue[child = right];
        /**
         * 比较key与c，如果小于等于0，说明key比c还要更早执行，
         * 说明此时k就是key应该放在的位置，跳出循环
         */
        if (key.compareTo(c) <= 0)
            break;
        /**
         * 否则说明key在c后面执行
         * 将更早执行的c放在k（即c的父节点）位置
         */
        queue[k] = c;
        // 设置c的heapIndex为k
        setIndex(c, k);
        // 将k指向child（此时的右孩子的索引），继续下次循环
        k = child;
    }
    // 将key放在queue的k索引位置上
    queue[k] = key;
    // 设置key的heapIndex为k
    setIndex(key, k);
}

// 获取队首任务，带有超时机制
public RunnableScheduledFuture poll(long timeout, TimeUnit unit)
        throws InterruptedException {
    // 计算超时时间
    long nanos = unit.toNanos(timeout);
    // 加锁
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        // 无限循环
        for (;;) {
            // 获取queue中索引为0位置的任务（即任务）为first
            RunnableScheduledFuture first = queue[0];
            /**
             * 如果first为null，表示此时queue是空的，
             * 检查剩余的超时时间，如果剩余时间小于等于0，表示超时了，直接返回null
             * 否则使用available进入超时等待
             */
            if (first == null) {
                if (nanos <= 0)
                    return null;
                else
                    nanos = available.awaitNanos(nanos);
            } else {
                // 走到这里表示取到了first不为null，获取其延迟时间
                long delay = first.getDelay(TimeUnit.NANOSECONDS);
                // 如果延迟时间小于等于0，表示该任务应该被执行了
                if (delay <= 0)
                    // 调用finishPoll()将其返回并对堆进行调整
                    return finishPoll(first);
                // 走到这里表示first任务的延迟时间还大于0，即还没有到执行时间
                if (nanos <= 0)
                    // 如果此时超时了，就直接返回null
                    return null;
                /**
                 * 走到这里表示没有超时，
                 * 如果超时时间小于延迟执行时间delay，
                 * 或者超时时间虽然大于或等于延迟时间，但leader不为null（表示队首已经有任务在等待了），
                 * 如果是就进入超时等待，等待时间为nanos
                 */
                if (nanos < delay || leader != null)
                    nanos = available.awaitNanos(nanos);
                else {
                    /**
                     * 走到表示超时时间大于等于延迟时间，且leader为null
                     * 使用leader记录当前线程
                     */
                    Thread thisThread = Thread.currentThread();
                    leader = thisThread;
                    try {
                        // 进入超时等待，超时时间为delay，返回值为未等待的时间（可能中途被中断了，或者被唤醒）
                        long timeLeft = available.awaitNanos(delay);
                        // 等待从超时时间中减去已等待的时间，即为剩余的超时时间
                        nanos -= delay - timeLeft;
                    } finally {
                        /**
                         * 超时等待结束后
                         * 如果leader还为当前线程，就将leader置为null
                         */
                        if (leader == thisThread)
                            leader = null;
                    }
                }
            }
        }
    } finally {
        /**
         * 最终当某个任务被返回后
         * 如果leader为null（表示此时队首没有任务在超时等待过程中），
         * 且queue首任务不为null（表示还有任务未执行）时，
         * 则唤醒等待在available上的线程
         */
        if (leader == null && queue[0] != null)
            available.signal();
        // 解锁
        lock.unlock();
    }
}

// 获取队首任务
public RunnableScheduledFuture take() throws InterruptedException {
    // 加锁，可中断
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        // 无限循环
        for (;;) {
            // 获取queue中索引为0位置的任务（即任务）为first
            RunnableScheduledFuture first = queue[0];
            // 如果first为null，表示此时queue是空的，进入等待
            if (first == null)
                available.await();
            else {
                // 走到这里表示取到了first不为null，获取其延迟时间
                long delay = first.getDelay(TimeUnit.NANOSECONDS);
                // 如果延迟时间小于等于0，表示该任务应该被执行了
                if (delay <= 0)
                    // 调用finishPoll()将其返回并对堆进行调整
                    return finishPoll(first);
                else if (leader != null)
                /**
                 * 否则表示任务还没有到执行时间，判断leader是否为null，
                 * 如果leader不为null，表示已经有任务（即leader）在队首进行等待了
                 * 那么就无条件进入等待状态
                 */
                    available.await();
                else {
                    /**
                     * 否则说明leader为null，表示此时还没有任务在队首等待
                     * 使用leader记录当前线程，然后使当前线程进入超时等待
                     */
                    Thread thisThread = Thread.currentThread();
                    leader = thisThread;
                    try {
                        // 然后进入带有超时机制的等待，超时时间为delay
                        available.awaitNanos(delay);
                    } finally {
                        /**
                         * 超时等待结束后
                         * 如果leader还为当前线程，就将leader置为null
                         */
                        if (leader == thisThread)
                            leader = null;
                    }
                }
            }
        }
    } finally {
        /**
         * 最终当某个任务被返回后
         * 如果leader为null（表示此时队首没有任务在超时等待过程中），
         * 且queue首任务不为null（表示还有任务未执行）时，
         * 则唤醒等待在available上的线程
         */
        if (leader == null && queue[0] != null)
            available.signal();
        // 解锁
        lock.unlock();
    }
}

// 从queue中移除任务x
public boolean remove(Object x) {
    // 加锁
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        // 查找x在queue中的索引
        int i = indexOf(x);
        // 如果返回值小于0表示没找到，直接返回false
        if (i < 0)
            return false;

        /**
         * 走到此处表示查找到了，i即为x在queue中的索引
         * 将queue中i位置的任务的heapIndex设置为-1（如果x是ScheduledFutureTask类型的话）
         */
        setIndex(queue[i], -1);
        // 计算移除后的size大小
        int s = --size;
        // 获取最后一个任务replacement
        RunnableScheduledFuture replacement = queue[s];
        // 将queue中s位置（即最后有任务的位置）上的任务置为null
        queue[s] = null;
        /**
         * 如果s与i不同，表示移除的不是最后一个任务
         * 此时要将i位置的缺补上
         * 补缺方式是将最后一个任务放在i位置，然后尝试对其进行下沉或上浮操作
         * 先尝试下沉，如果下沉结束发现最后一个任务还处于i位置，则表明该任务没有移动
         * 因此尝试对该任务进行上浮操作
         */
        if (s != i) {
            // 需要将replacement从i位置尝试下沉操作
            siftDown(i, replacement);
            /**
             * 如果下沉操作完成，i位置任务还为replacement
             * 则表示replacement没有下沉，尝试上浮操作
             */
            if (queue[i] == replacement)
                siftUp(i, replacement);
        }
        // 返回true表示移除成功
        return true;
    } finally {
        // 解锁
        lock.unlock();
    }
}

/**
 * 将队列中的延时过期任务依次转移，直到遇到第一个延时未过期的任务停止
 * @param c 集合
 * @return 转移的个数
 */
public int drainTo(Collection<? super Runnable> c) {
    // 检查参数
    if (c == null)
        throw new NullPointerException();
    if (c == this)
        throw new IllegalArgumentException();
    // 加锁
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        RunnableScheduledFuture first;
        int n = 0;
        // 不断移除队首延时过期的任务，直到遇到第一个延时未过期的任务停止
        while ((first = pollExpired()) != null) {
            // 将移除的任务添加到集合c中
            c.add(first);
            // 计数
            ++n;
        }
        // 返回转移的个数
        return n;
    } finally {
        // 解锁
        lock.unlock();
    }
}

/**
 * 将队列中的延时过期任务依次转移，
 * 最多转移maxElements个，或者直到遇到第一个延时未过期的任务停止
 * @param c 集合
 * @param maxElements 最多转移的个数
 * @return 转移的个数
 */
public int drainTo(Collection<? super Runnable> c, int maxElements) {
    // 检查参数
    if (c == null)
        throw new NullPointerException();
    if (c == this)
        throw new IllegalArgumentException();
    if (maxElements <= 0)
        return 0;
    // 加锁
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        RunnableScheduledFuture first;
        int n = 0;
        // 不断移除队首延时过期的任务，直到计数大于等于maxElements，或者遇到第一个延时未过期的任务停止
        while (n < maxElements && (first = pollExpired()) != null) {
            // 将移除的任务添加到集合c中
            c.add(first);
            // 计数
            ++n;
        }
        // 返回转移的个数
        return n;
    } finally {
        // 解锁
        lock.unlock();
    }
}

/**
 * Return and remove first element only if it is expired.
 * Used only by drainTo.  Call only when holding lock.
 * 当队首任务延时过期了，将其移除；一般用于drainTo()方法中
 */
private RunnableScheduledFuture pollExpired() {
    // 获取队首任务
    RunnableScheduledFuture first = queue[0];
    // 如果队首任务为null，或者不为null但延时时间大于0
    if (first == null || first.getDelay(TimeUnit.NANOSECONDS) > 0)
        // 返回null
        return null;
    // 否则满足条件，将其从堆中移除，调整堆并返回该任务
    return finishPoll(first);
}

// 迭代器
public Iterator<Runnable> iterator() {
    // 直接以queue转为的数组创建迭代器
    return new Itr(Arrays.copyOf(queue, size));
}

/**
 * Snapshot iterator that works off copy of underlying q array.
 * 迭代器类
 */
private class Itr implements Iterator<Runnable> {
    // 记录需要迭代的数组
    final RunnableScheduledFuture[] array;
    // 当前需要返回的元素的索引游标
    int cursor = 0;     // index of next element to return
    // 上一次返回的元素
    int lastRet = -1;   // index of last element, or -1 if no such

    // 构造方法
    Itr(RunnableScheduledFuture[] array) {
        // 将传入的数组进行记录
        this.array = array;
    }

    // 是否还有下一个
    public boolean hasNext() {
        return cursor < array.length;
    }

    // 获取下一个元素
    public Runnable next() {
        // 如果游标大于等于数组长度，表示迭代到最末尾了，抛出异常即可
        if (cursor >= array.length)
            throw new NoSuchElementException();
        // 否则使用lastRet记录当前游标
        lastRet = cursor;
        // 然后返回当前游标处的元素
        return array[cursor++];
    }

    // 移除元素
    public void remove() {
        // 如果lastRet小于0说明它还没有指向任何元素
        if (lastRet < 0)
            throw new IllegalStateException();
        // 使用DelayedWorkQueue的移除方法移除元素
        DelayedWorkQueue.this.remove(array[lastRet]);
        // 移除后将lastRet置为-1
        lastRet = -1;
    }
}

// 查看队首任务
public RunnableScheduledFuture peek() {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        // 返回queue数组中第一个任务（并未取出）
        return queue[0];
    } finally {
        lock.unlock();
    }
}

// 清除队列任务
public void clear() {
    // 加锁
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        // 遍历queue数组
        for (int i = 0; i < size; i++) {
            // 取出i位置任务为t
            RunnableScheduledFuture t = queue[i];
            if (t != null) {
                // 如果t不为null，将queue的i位置任务置为null
                queue[i] = null;
                // 将t的heapIndex置为-1
                setIndex(t, -1);
            }
        }
        // size置为0
        size = 0;
    } finally {
        // 解锁
        lock.unlock();
    }
}

// 转为数组
public Object[] toArray() {
    // 加锁
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        // 进行拷贝并返回
        return Arrays.copyOf(queue, size, Object[].class);
    } finally {
        // 解锁
        lock.unlock();
    }
}

// 转为数组
@SuppressWarnings("unchecked")
public <T> T[] toArray(T[] a) {
    // 加锁
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        // 如果a的容量小于任务总数，将创建一个新的数组，拷贝任务后返回
        if (a.length < size)
            return (T[]) Arrays.copyOf(queue, size, a.getClass());
        // 否则直接进行拷贝，
        System.arraycopy(queue, 0, a, 0, size);
        // 如果a的容量大于任务总数，将a中size位置的元素置为null
        if (a.length > size)
            a[size] = null;
        // 返回a
        return a;
    } finally {
        // 解锁
        lock.unlock();
    }
}