（原创）定时线程池中scheduleWithFixedDelay和scheduleAtFixedRate的区别

scheduleAtFixedRate 没有什么歧义，很容易理解，就是每隔多少时间，固定执行任务。

scheduleWithFixedDelay 比较容易有歧义

貌似也是推迟一段时间执行任务，但Oracle的解释如下,

delay

的意思是当结束前一个执行后延迟的时间

scheduleWithFixedDelay Parameters:

command

- the task to execute

initialDelay

- the time to delay first execution

delay

- the delay between the termination of one execution and the commencement of the next

unit

- the time unit of the initialDelay and delay parameters

scheduleWithFixedDelay 比如当前一个任务结束的时刻，开始结算间隔时间，如0秒开始执行第一次任务，任务耗时5秒，任务间隔时间3秒，那么第二次任务执行的时间是在第8秒开始。

import java.util.Date;

public class WorkerThread implements Runnable{

private String command;

public WorkerThread(String s){
this.command=s;
}

@Override
public void run() {
System.out.println(Thread.currentThread().getName()+" Start. Time = "+new Date());
processCommand();
System.out.println(Thread.currentThread().getName()+" End. Time = "+new Date());
}

private void processCommand() {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}

@Override
public String toString(){
return this.command;
}
}

import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledThreadPool {

public static void main(String[] args) throws InterruptedException {
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);

System.out.println("Current Time = "+new Date());
for(int i=0; i<10; i++){
Thread.sleep(1000);
WorkerThread worker = new WorkerThread("do heavy processing");
//scheduledThreadPool.schedule(worker, 3, TimeUnit.SECONDS);
//scheduledThreadPool.scheduleAtFixedRate(worker, 5, 5, TimeUnit.SECONDS);
scheduledThreadPool.scheduleWithFixedDelay(worker, 5, 3, TimeUnit.SECONDS);
}
Thread.sleep(300000);

scheduledThreadPool.shutdown();
while(!scheduledThreadPool.isTerminated()){
}
System.out.println("Finished all threads");
}

}