黑马程序员技术交流社区

标题: 线程池的疑问 [打印本页]
作者: 王睿    时间: 2012-3-4 16:05
标题: 线程池的疑问
  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.                                 );
复制代码
作者: 段玉超    时间: 2012-3-4 16:19
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 17:52
段玉超 发表于 2012-3-4 16:19
scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnitunit)

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


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


作者: 段玉超    时间: 2012-3-4 23:26
  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.                 });

  10.                  Executors.newScheduledThreadPool(3).scheduleWithFixedDelay(new Task("任务"), 2000, 1000, TimeUnit.MILLISECONDS);


  13.                 //thread.start();
  14.         }
  15. }

  17. class Task implements Runnable
  18. {
  19.         private long createTime = System.currentTimeMillis();
  20.         private String  name ;
  21.         public Task(){
  22.         }

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

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



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2