Java 线程 — ScheduledThreadPoolExecutor

ScheduledThreadPoolExecutor

该类继承自ThreadPoolExecutor，增加了定时执行线程和延迟启动的功能，这两个功能是通过延时队列DelayedWorkQueue辅助实现的。

线程池里面的线程需要从队列里面获取任务，任务根据延时时长是有顺序的，线程池的线一直获取延时最短的任务，也就是最小二叉堆中的堆顶元素，这个时候堆顶元素成为各个线程争夺的资源，

1. 在获取堆顶元素的时候加锁（ReentrabtLock，可重入，独占锁），这样获取到锁的线程开始获取堆顶元素，其他线程在不能获取锁被阻塞
2. 如果堆顶元素的延时还没有到，当前线程成为leader线程，进入超时等待
   
   1.1. 这个时候其他被阻塞的线程有机会获取锁
   
   1.2. 获取锁的线程发现leader线程已经另有其人（leader != null）
   
   1.3. 线程进入等待，available.await();
3. 如果线程等待正常结束（时间已到），让出leander地位，再次进入循环，发现delayed <= 0，获取对顶元素，并重新堆化筛选出堆顶元素，调用available.signal()唤醒等待的线程（比如1.1的情况），释放锁
   
   3.1 假设是1.1里面的线程被唤醒（实际不一定，唤醒的也可能是其他线程）
   
   3.2 重复1、2、3、4的流程
4. 线程获取到任务开始运行，运行ScheduledFutureTask.run方法，如果是定时任务的话，会重新计算延时时间，将任务加入队列，等待下次运行

DelayedWorkQueue

这个队列是一个阻塞的队列，队列基于二叉堆实现的，根据线程距离下次运行的时间比较大小，所以添加和删除元素都是二叉堆的重新堆化

offer

put、add都是调用下面的offer方法

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

// 队列扩容，每次增加50%，直到Integer的最大值
private void grow() {
    int oldCapacity = queue.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1); // grow 50%
    if (newCapacity < 0) // overflow
        newCapacity = Integer.MAX_VALUE;
    queue = Arrays.copyOf(queue, newCapacity);
}

// 新加入元素之后重新堆化，最小堆
private void siftUp(int k, RunnableScheduledFuture key) {
    while (k > 0) {
    	// 二叉堆的特性父节点的序号 = (当前节点序号 - 1) / 2
        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);
}

take

take的时候使用的是leader-follow模式，只有一个leader，其他都是follow，在每次finishPoll的时候都会选举出新的

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(TimeUnit.NANOSECONDS);
                if (delay <= 0)
                	// 延迟或者定时时间（其实定时间也是一种延迟）到，从队列中取出任务执行
                    return finishPoll(first);
                // 如果leader != null 说明leader是另外的线程（有可能是leader线程在available.awaitNanos(delay)）是leader，那么当前线程进入等待
                else if (leader != null)
                    available.await();
                else {
                	// 没有leader线程的时候，当前线程成为新的leader
                    Thread thisThread = Thread.currentThread();
                    leader = thisThread;
                    try {
                    	// 这里进行超时等待，超过delay之后就会恢复运行，或者是被其他线程唤醒
                        available.awaitNanos(delay);
                    } finally {
                        if (leader == thisThread)
                        	// 重置leader以便进入下一次循环
                            leader = null;
                    }
                }
            }
        }
    } finally {
    	// 队列不为空的时候发出signal，leader == null的条件是防止leader线程在available.awaitNanos(delay)的时候被唤醒
        if (leader == null && queue[0] != null)
            available.signal();
        lock.unlock();
    }
}

// 返回第一个等待的线程（延时已到），并将剩余元素再次堆化
private RunnableScheduledFuture finishPoll(RunnableScheduledFuture f) {
    int s = --size;
    RunnableScheduledFuture x = queue[s];
    queue[s] = null;
    if (s != 0)
        siftDown(0, x);
    setIndex(f, -1);
    return f;
}

// 因为key是原来堆中的元素位于堆得最底层，key本来就是较大的元素，
private void siftDown(int k, RunnableScheduledFuture key) {
    int half = size >>> 1;
    while (k < half) {
        int child = (k << 1) + 1;
        RunnableScheduledFuture c = queue[child];
        int right = child + 1;
        if (right < size && c.compareTo(queue[right]) > 0)
            c = queue[child = right];
        if (key.compareTo(c) <= 0)
        	// 找到key的位置，大于父节点，小于子节点
            break;
        queue[k] = c;
        setIndex(c, k);
        k = child;
    }
    queue[k] = key;
    setIndex(key, k);
}

问题

period线程怎么实现定时调用

setNextRunTime会重新计算下次运行需要等待的时间，因为period线程运行完后已经从队列中删除，在reExecutePeriodic方法中会重新进入队列，调用ensurePrestart重新开始执行任务

public void run() {
    boolean periodic = isPeriodic();
    if (!canRunInCurrentRunState(periodic))
        cancel(false);
    else if (!periodic)
    	// 非定时线程调用FutureTask的run方法
        ScheduledFutureTask.super.run();
    else if (ScheduledFutureTask.super.runAndReset()) {	// 定时线程调用FutureTask的runAndReset方法
    	// 设置下次运行时间
        setNextRunTime();
        // 重新准备运行
        reExecutePeriodic(outerTask);
    }
}

void reExecutePeriodic(RunnableScheduledFuture<?> task) {
    if (canRunInCurrentRunState(true)) {
    	// task进入队列
        super.getQueue().add(task);
        if (!canRunInCurrentRunState(true) && remove(task))
            task.cancel(false);
        else
            ensurePrestart();
    }
}

void ensurePrestart() {
    int wc = workerCountOf(ctl.get());
    // 进入线程池等待运行，接下来就和ThreadPoolExecutor运行顺序一样了
    if (wc < corePoolSize)
        addWorker(null, true);
    else if (wc == 0)
        addWorker(null, false);
}

线程运行完成之后任务会不会从队列中删除，怎么删除的？

会删除，在finnishPoll中，重新堆化选出堆顶元素，原来的堆顶元素被覆盖，也就是删除了