ScheduledExecutorService类 scheduleWithFixedDelay() 和 scheduleFixedRate() 区别

先说scheduleWithFixedDelay()，

scheduleWithFixedDelay从字面意义上可以理解为就是以固定延迟（时间）来执行线程任务，它实际上是不管线程任务的执行时间的，每次都要把任务执行完成后再延迟固定时间后再执行下一次。

而scheduleFixedRate呢，是以固定频率来执行线程任务，固定频率的含义就是可能设定的固定时间不足以完成线程任务，但是它不管，达到设定的延迟时间了就要执行下一次了。

不知道大家理解了没有，下面是示例：

 

[java] view plain copy

1. public static void scheduleWithFixedDelay() {  
2.   
3.     final ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);  
4.     // 响铃线程  
5.     final Runnable beeper = new Runnable() {  
6.         public void run() {  
7.             SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
8.             long time = (long) (Math.random() * 1000);  
9.             // 输出线程的名字和使用目标对象及休眠的时间  
10.             System.out.println(sf.format(new Date())+"线程:"+Thread.currentThread().getName()+":Sleeping"+time+"ms");  
11.             try {  
12.                 Thread.sleep(time);  
13.             } catch (InterruptedException e) {  

[java] view plain copy

1.         }  
2.         }  
3.     };  
4.     // 设定执行线程计划,初始10s延迟,每次任务完成后延迟10s再执行一次任务  
5.     final ScheduledFuture<?> sFuture=scheduledExecutorService.scheduleWithFixedDelay(beeper,10,10,TimeUnit.SECONDS);  
6.   
7.     // 40s后取消线程任务  
8.     scheduledExecutorService.schedule(new Runnable() {  
9.         public void run() {  
10.             sFuture.cancel(true);  
11.             scheduledExecutorService.shutdown();  
12.         }  
13.     }, 40, TimeUnit.SECONDS);  
14.   
15. }  

执行结果：

2013-10-16 10:45:51 线程：pool-1-thread-2:Sleeping 726ms
2013-10-16 10:46:02 线程：pool-1-thread-2:Sleeping 288ms
2013-10-16 10:46:12 线程：pool-1-thread-2:Sleeping 294ms

从执行结果数量看只执行了3次，因为每次要把任务执行完成再执行下一次，导致40s按10s的延迟时间不足以执行4次。

 

 

[html] view plain copy

1. public static void scheduleAtFixedRate() {  
2.     // 声明线程池  
3.     final ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);  
4.     // 响铃线程  
5.     final Runnable beeper = new Runnable() {  
6.         public void run() {  
7.             SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
8.             long time = (long) (Math.random() * 1000);  
9.             // 输出线程的名字和使用目标对象及休眠的时间  
10.             System.out.println(sf.format(new Date()) + " 线程：" + Thread.currentThread().getName() + ":Sleeping " + time + "ms");  
11.             try {  
12.                 Thread.sleep(time);  
13.             } catch (InterruptedException e) {  
14.             }  
15.         }  
16.     };  
17.     // 计划响铃，初始延迟10s然后以10s的频率执行响铃  
18.     final ScheduledFuture<?> beeperHandle = scheduledExecutorService.scheduleAtFixedRate(beeper, 10, 10, TimeUnit.SECONDS);  
19.   
20.     // 取消响铃并关闭线程  
21.     final Runnable cancelBeeper = new Runnable() {  
22.         public void run() {  
23.             System.out.println(Thread.currentThread().getName() + "CANCEL...");  
24.             beeperHandle.cancel(true);  
25.             scheduledExecutorService.shutdown();  
26.         }  
27.     };  
28.     // 60s后执行scheduleAtFixedRate  
29.     scheduledExecutorService.schedule(cancelBeeper, 40, TimeUnit.SECONDS);  
30. }  

 

执行结果：

2013-10-16 10:16:50 线程：pool-1-thread-1:Sleeping 868ms
2013-10-16 10:17:00 线程：pool-1-thread-1:Sleeping 587ms
2013-10-16 10:17:10 线程：pool-1-thread-1:Sleeping 313ms
2013-10-16 10:17:20 线程：pool-1-thread-1:Sleeping 969ms
pool-1-thread-1CANCEL...

看时间我们就可以知道是每个10s就执行下一次了。