1.                 Executors.newScheduledThreadPool(3).scheduleAtFixedRate(
   
2.                                 new Runnable(){
   
3.                                         @Override
   
4.                                         public void run() {
   
5.                                                 // TODO Auto-generated method stub
   
6.                                                 System.out.println("爆炸....." );
   
7.                                         }
   
8.                                 },
   
9.                                 10, //延迟10秒执行run()
   
10.                                 3, //之后每隔3秒执行一次run()
    
11.                                 TimeUnit.SECONDS
    
12.                                 );
    
13.                 //scheduleWithFixedDelay和scheduleAtFixedRate的区别是什么啊？？？？？？？？执行结果没什么区别好像
    
14.                 Executors.newScheduledThreadPool(3).scheduleWithFixedDelay(
    
15.                                 new Runnable() {
    
16.                                        
    
17.                                         @Override
    
18.                                         public void run() {
    
19.                                                 // TODO Auto-generated method stub
    
20.                                                 System.out.println("爆炸");
    
21.                                         }
    
22.                                 },
    
23.                                 10,
    
24.                                 3,
    
25.                                 TimeUnit.SECONDS
    
26.                                 );

复制代码

scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnitunit)

         创建并执行一个在给定初始延迟后首次启用的定期操作，后续操作具有给定的周期；也就是将在 initialDelay 后开始执行，然后在initialDelay+period 后执行，接着在 initialDelay + 2 * period 后执行，依此类推。

scheduleWithFixedDelay(Runnable command, long initialDelay, long delay,TimeUnit unit)

         创建并执行一个在给定初始延迟后首次启用的定期操作，随后，在每一次执行终止和下一次执行开始之间都存在给定的延迟。

段玉超 发表于 2012-3-4 16:19
scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnitunit)

         创建并 ...

在每一次执行终止和下一次执行开始之间都存在给定的延迟。

也就是说每次都会延迟10执行，每隔3秒执行一次？  但执行结果不是这样啊？是我理解错了？能否代码演示一下？

1.         public static void main(String[] args)
   
2.         {
   
3.                 Thread thread = new Thread(new Runnable(){
   
4.                           
   
5.                                 public void run(){
   
6.                                         System.out.print("asdfsaf");
   
7.                                 }
   
8.                 });
   
9. 
   
10.                  Executors.newScheduledThreadPool(3).scheduleWithFixedDelay(new Task("任务"), 2000, 1000, TimeUnit.MILLISECONDS);
    
11. 
    
12. 
    
13.                 //thread.start();
    
14.         }
    
15. }
    
16. 
    
17. class Task implements Runnable
    
18. {
    
19.         private long createTime = System.currentTimeMillis();
    
20.         private String  name ;
    
21.         public Task(){
    
22.         }
    
23. 
    
24.         public Task(String name){
    
25.                 this.name = name;
    
26.         }
    
27.         public void run(){
    
28.                
    
29.                         System.out.print("间隔"+(System.currentTimeMillis()-createTime));
    
30.             createTime=System.currentTimeMillis();
    
31.                         try
    
32.                         {
    
33.                                 Thread.sleep(3000);
    
34.                         }
    
35.                         catch (Exception ex)
    
36.                         {
    
37.                         }
    
38.                        
    
39.                         System.out.print(name+"被调用\n");
    
40.         }
    
41. }

复制代码

你替换一下 方法 看看结果有什么不同 就知道了。
scheduleAtFixedRate在制定反复执行一个task的计划时，每一次 执行这个task的计划执行时间在最初就被定下来了，也就是scheduledExecutionTime(第n次)=firstExecuteTime +n*periodTime；如果第n次执行task时，由于某种原因这次执行时间过长，执行完后的systemCurrentTime>= scheduledExecutionTime(第n+1次)，则此时不做period间隔等待，立即执行第n+1次task，而接下来的第n+2次的 task的scheduledExecutionTime(第n+2次)依然还是firstExecuteTime+（n+2)*periodTime这 在第一次执行task就定下来了。说白了，这个方法更注重保持执行频率的稳定。
与 Javascript 中的setinterval。 类似。

scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)
          创建并执行一个在给定初始延迟后首次启用的定期操作，随后，在每一次执行终止和下一次执行开始之间都存在给定的延迟。这个方法更注重保持间隔时间的稳定。
也就是说 无论 上一次Task执行多长时间，下一次 执行总是在 delay 之后。
与Javascript 中 setTimeout 类似。

段玉超 发表于 2012-3-4 23:26
你替换一下 方法 看看结果有什么不同 就知道了。
scheduleAtFixedRate在制定反复执行一个task的计划时，每 ...

谢了哥们明白了！非常感谢:victory: