这两个方法字面意思能看懂，但是具体方法是怎么执行的呢？不知道大家能不能写个代码能直观的看出来的？

1. import java.util.concurrent.Executors;import java.util.concurrent.TimeUnit;
   
2. 
   
3. 
   
4. public class Schedule {
   
5.         public static void main(String[] args){
   
6.                
   
7.                 Executors.newScheduledThreadPool(2).scheduleAtFixedRate(
   
8.                                 new Runnable(){
   
9.                                         public void run(){System.out.println("go");
   
10.                                         }},
    
11.                                 1,
    
12.                                 1,
    
13.                                 TimeUnit.SECONDS);
    
14.                 //用固定频率调度方法调度
    
15.                 Executors.newScheduledThreadPool(2).scheduleWithFixedDelay(
    
16.                                 new Runnable(){
    
17.                                         public void run(){ System.out.println("oly,oly,oly");
    
18.                                         }},
    
19.                                 2, 1,
    
20.                                 TimeUnit.SECONDS);
    
21.                 //用固定的延时来调度
    
22.         }
    
23. }
    
24. 
    
25. 
    

复制代码

楼主看这代码好像也能看出来作用啊，第一个很好懂啊，就是按频率运行线run()方法，每隔一秒楼主会看到一个go ,第二个是按延迟，不过其实从运行结果来看上面两段代码不同就在于上来按频率调度的就先运行了一次，然后按延迟执行的才开始，所以开始会有两个GO一个OLY,运行结果如下:
go
go
oly,oly,oly
go
oly,oly,oly

     通过测试，固定频率是按照任务开始时间算的，比如：02秒开始，频率是3秒，如果任务在3秒内完成，
则下次任务开始时间是05秒，如果超过3秒，下次任务推迟执行。
    而固定延时是按照任务结束时间算的，比如：02秒开始，延时3秒，不论任务执行时间多少，下次任务都是
在上次任务完成后3秒才开始执行。

1. import java.util.Date;
   
2. import java.util.concurrent.Executors;
   
3. import java.util.concurrent.TimeUnit;
   
4. 
   
5. public class Demo02 {
   
6.         static int rateIndex;
   
7.         static int delayIndex;
   
8.         public static void main(String[] args) {
   
9.                 //rate();
   
10.                 delay();
    
11.         }
    
12.         // 用固定频率调度方法调度：
    
13.         public static void rate(){               
    
14.                 Executors.newScheduledThreadPool(2).scheduleAtFixedRate(new Runnable() {
    
15.                         public void run() {
    
16.                                 rateIndex++;
    
17.                                 Date d = new Date();
    
18.                                 System.out.println(d+"rate 第"+rateIndex+"次---开始");
    
19.                                 try {
    
20.                                         Thread.sleep(4000);        //休眠4秒，模拟任务执行时间
    
21.                                 } catch (InterruptedException e) {
    
22.                                         e.printStackTrace();
    
23.                                 }
    
24.                                 Date d2 = new Date();
    
25.                                 System.out.println(d2+"rate 第"+rateIndex+"次---结束");
    
26.                         }
    
27.                 }, 1, 3, TimeUnit.SECONDS);
    
28. 
    
29.         }
    
30.         // 用固定的延时来调度
    
31.         public static void delay(){               
    
32.                 Executors.newScheduledThreadPool(2).scheduleWithFixedDelay(
    
33.                                 new Runnable() {
    
34.                                         public void run() {
    
35.                                                 delayIndex++;
    
36.                                                 Date d = new Date();
    
37.                                                 System.out.println(d+"delay 第"+delayIndex+"次---开始");
    
38.                                                 try {
    
39.                                                         Thread.sleep(2000);
    
40.                                                 } catch (InterruptedException e) {
    
41.                                                         e.printStackTrace();
    
42.                                                 }
    
43.                                                 Date d2 = new Date();
    
44.                                                 System.out.println(d2+"delay 第"+delayIndex+"次---结束");
    
45.                                         }
    
46.                                 }, 1, 3, TimeUnit.SECONDS);
    
47.         }
    
48. }

复制代码