七. ScheduledThreadPoolExecutor原理解析-ScheduledFutureTask

素颜马尾好姑娘i 2024-03-29 14:42 84阅读 0赞

### 正文 ###

已知提交到`ScheduledThreadPoolExecutor`中的任务均会被封装成`ScheduledFutureTask`，因此本篇文章将对`ScheduledFutureTask`的原理进行分析。

### 正文 ###

首先查看`ScheduledFutureTask`的类图，如下所示。

![在这里插入图片描述][fbcdc6178e8d40afb3f69312ab7ecd9f.jpeg_pic_center]

即`ScheduledFutureTask`继承了`FutureTask`的功能，同时实现了`RunnableScheduledFuture`接口的方法。下面看一下`ScheduledFutureTask`的字段。

private class ScheduledFutureTask<V>
    		extends FutureTask<V> implements RunnableScheduledFuture<V> {
        
    
    	// 任务添加到ScheduledThreadPoolExecutor中时分配的一个序列号
    	private final long sequenceNumber;
    
    	// 任务下次执行的时间点
    	private long time;
    
    	// 任务的执行间隔
    	// 大于0表示任务是以固定周期执行的任务
    	// 小于0表示任务是以固定延时执行的任务
    	// 等于0表示任务是非重复执行的任务
    	private final long period;
    
    	// 指向当前任务本身
    	RunnableScheduledFuture<V> outerTask = this;
    
    	// 任务在延时队列中的索引
    	int heapIndex;
    
    	......
    
    }

因为`ScheduledFutureTask`是作为元素存储在基于小根堆实现的延时优先级队列中，所以`ScheduledFutureTask`提供了**sequenceNumber**和**time**这两个字段用于堆中元素之间的比较，然后**heapIndex**就是`ScheduledFutureTask`在延时队列中的索引，即元素在堆数组中的索引。

`ScheduledFutureTask`提供了三个构造方法，如下所示。

ScheduledFutureTask(Runnable r, V result, long ns) {
        
    	super(r, result);
    	this.time = ns;
    	this.period = 0;
    	this.sequenceNumber = sequencer.getAndIncrement();
    }
    
    ScheduledFutureTask(Runnable r, V result, long ns, long period) {
        
    	super(r, result);
    	this.time = ns;
    	this.period = period;
    	this.sequenceNumber = sequencer.getAndIncrement();
    }
    
    ScheduledFutureTask(Callable<V> callable, long ns) {
        
    	super(callable);
    	this.time = ns;
    	this.period = 0;
    	this.sequenceNumber = sequencer.getAndIncrement();
    }

在`ScheduledFutureTask`的构造方法中，会先构造父类`FutureTask`，然后根据构造方法入参设置任务下次的执行时间点和任务的执行间隔，并为任务分配**sequenceNumber**。

下面再看一下`ScheduledFutureTask`是如何进行比较的。`ScheduledFutureTask`实现了`Comparable`接口，其实现的`compareTo()`方法如下所示。

public int compareTo(Delayed other) {
        
    	if (other == this)
    		return 0;
    	if (other instanceof ScheduledFutureTask) {
        
    		ScheduledFutureTask<?> x = (ScheduledFutureTask<?>)other;
    		// 优先比较任务下一次执行的时间点先后，越先执行time越小
    		long diff = time - x.time;
    		if (diff < 0)
    			return -1;
    		else if (diff > 0)
    			return 1;
    		// 如果任务下一次执行的时间点相同，则比较sequenceNumber
    		else if (sequenceNumber < x.sequenceNumber)
    			return -1;
    		else
    			return 1;
    	}
    	long diff = getDelay(NANOSECONDS) - other.getDelay(NANOSECONDS);
    	return (diff < 0) ? -1 : (diff > 0) ? 1 : 0;
    }

两个`ScheduledFutureTask`进行比较时，会先比较下一次任务执行的时间先后，如果下一次任务执行的时间一样，则再根据**sequenceNumber**进行比较。

最后再看一下`ScheduledFutureTask`的`run()`方法，如下所示。

public void run() {
        
    	boolean periodic = isPeriodic();
    	if (!canRunInCurrentRunState(periodic))
    		// 如果当前线程池状态下不允许执行任务，则关闭任务
    		cancel(false);
    	else if (!periodic)
    		// 执行延时任务
    		ScheduledFutureTask.super.run();
    	// 执行定时任务，然后为定时任务设置下一次执行的时间点并添加到延时队列中
    	else if (ScheduledFutureTask.super.runAndReset()) {
        
    		setNextRunTime();
    		reExecutePeriodic(outerTask);
    	}
    }

`ScheduledFutureTask`在执行`run()`方法时会先根据**periodic**字段的值判断任务是延时任务（只在延时时间到了后执行一次）还是定时任务（需要根据指定间隔重复执行），如果是定时任务，那么在定时任务执行完之后，会为定时任务设置下一次执行的时间点并重新添加到延时队列中。设置定时任务下一次执行的时间点的`setNextRunTime()`实现如下。

// 设置任务的下一次执行的时间点
    private void setNextRunTime() {
        
    	long p = period;
    	// 如果是以固定周期执行的任务，则下一次执行的时间点就是上一次执行的时间点加上执行间隔
    	if (p > 0)
    		time += p;
    	// 如果是以固定延时执行的任务，则下一次执行的时间点就是当前时间加上执行间隔
    	else
    		time = triggerTime(-p);
    }

### 总结 ###

关于`ScheduledFutureTask`，注意点如下。

1.  `ScheduledFutureTask`提供了**sequenceNumber**和**time**这两个字段用于堆中元素之间的比较，且比较规则是：先比较下一次任务执行的时间**time**的先后，如果下一次任务执行的时间一样，则再根据**sequenceNumber**进行比较；
2.  定时任务执行完毕后，才会设置定时任务的下一次执行时间**time**。

[fbcdc6178e8d40afb3f69312ab7ecd9f.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/4906e44c31f14c03a43ef7a675b7eb6b.png