blocks|key|2750477|text|文档确实解释了其中的区别：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2750478|日程安排：|2750479|2750480|在固定延迟执行中，每次执行都是相对于上次执行的实际执行时间进行调度的。如果由于任何原因(例如垃圾收集或其他后台活动)而延迟执行，则后续执行也将延迟。|blockquote|2750481|2750482|2750483|因此，假设延迟为5秒，每个任务需要2秒，您将得到|2750484|TTWWWTTWWWTTWWWTT|code-block|syntax|javascript|2750485|其中T表示任务执行1秒，W表示等待1秒。|offset|length|style|CODE|2750486|但现在假设发生了一个长GC+(由G表示)，并延迟了第二个任务，第三个任务将在第二个任务开始5秒后启动，就好像长GC没有发生一样：|2750487|TTWWWGGTTWWWTTWWWTT|2750488|第三个任务在第二个任务开始5秒后开始。|2750489|scheduleAtFixedRate：|2750490|2750491|在固定速率执行中，每次执行都是相对于初始执行的调度执行时间进行调度的。如果由于任何原因(例如垃圾收集或其他后台活动)而延迟执行，则会快速连续发生两次或更多次执行，以“赶上”。|2750492|2750493|2750494|因此，使用与上面相同的延迟和相同的GC，您将得到|2750495|TTWWWGGTTWTTWWWTT|2750496|第三个任务开始3秒，而不是第二个任务后5秒，以赶上。|2750497|entityMap^0|0|0|0|0|0|0|0|0|2|1|C|1|0|G|1|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1I|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]|$1|E|3|F|5|G|7|1K|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|1M|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|1N|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|1O|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|1P|8|@$S|1Q|T|1R|U|V]|$S|1S|T|1T|U|V]]|9|@]|A|$]]|$1|W|3|X|5|6|7|1U|8|@$S|1V|T|1W|U|V]]|9|@]|A|$]]|$1|Y|3|Z|5|N|7|1X|8|@]|9|@]|A|$O|P]]|$1|10|3|11|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|14|3|-4|5|6|7|20|8|@]|9|@]|A|$]]|$1|15|3|16|5|G|7|21|8|@]|9|@]|A|$]]|$1|17|3|-4|5|6|7|22|8|@]|9|@]|A|$]]|$1|18|3|-4|5|6|7|23|8|@]|9|@]|A|$]]|$1|19|3|1A|5|6|7|24|8|@]|9|@]|A|$]]|$1|1B|3|1C|5|N|7|25|8|@]|9|@]|A|$O|P]]|$1|1D|3|1E|5|6|7|26|8|@]|9|@]|A|$]]|$1|1F|3|-4|5|6|7|27|8|@]|9|@]|A|$]]]|1G|$]]

The documentation does explain the difference:

schedule:

<blockquote>
 In fixed-delay execution, each execution is scheduled relative to the actual execution time of the previous execution. If an execution is delayed for any reason (such as garbage collection or other background activity), subsequent executions will be delayed as well.
</blockquote>

So, suppose the delay is 5 seconds, and each task takes 2 seconds, you would get

<pre><code>TTWWWTTWWWTTWWWTT
</code></pre>

where <code>T</code> means 1 second for the task execution, and <code>W</code> means 1 second waiting.

But now suppose that a long GC (represented by a <code>G</code>) happens and delays the second task, the third one will start 5 seconds after the start of the second one, as if the long GC didn't happen:

<pre><code>TTWWWGGTTWWWTTWWWTT
</code></pre>

The third task starts 5 seconds after the second one.

scheduleAtFixedRate:

<blockquote>
 In fixed-rate execution, each execution is scheduled relative to the scheduled execution time of the initial execution. If an execution is delayed for any reason (such as garbage collection or other background activity), two or more executions will occur in rapid succession to "catch up.". 
</blockquote>

So, with the same delay as above, and the same GC, you would get

<pre><code>TTWWWGGTTWTTWWWTT
</code></pre>

The third task task starts 3 seconds instead of 5 after the second one, to catch up.

blocks|key|2750499|text|感谢@Nizet的回答，我已经为一些想要练习和学习的人写了一个示例代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2750500|import+java.util.Timer;
import+java.util.TimerTask;

public+class+TimerTest+{

++++public+static+void+main(String+args[]){
++++++++TimerTest.DelayTask+task+=+new+DelayTask();
++++++++Timer+timer+=+new+Timer();
++++++++/**
+++++++++*+Use+schedule+or+scheduletAtFixedrate+and+check+the+printed+result
+++++++++*/
++++++++timer.schedule(task,+0,+5000);
++++++++//timer.scheduleAtFixedRate(task,+0,+5000);
++++}

++++public+static+boolean+stop+=+false;

++++public+static+void+delayOneSec(String+status){
++++++++try{
++++++++++++System.out.print(status);
++++++++++++Thread.sleep(1000);
++++++++}catch(Exception+e){
++++++++++++e.printStackTrace();
++++++++}
++++}

++++static+class+DelayTask+extends+TimerTask{
++++++++int+count+=+2;

++++++++@Override
++++++++public+void+run()+{
++++++++++++//+TODO+Auto-generated+method+stub
++++++++++++stop+=+true;
++++++++++++for(int+i+=+0;+i+<+count;+i%2B%2B){
++++++++++++++++TimerTest.delayOneSec("T");
++++++++++++}
++++++++++++if(count+==+2){
++++++++++++++++count+=+6;
++++++++++++}else{
++++++++++++++++count+=+2;
++++++++++++}
++++++++++++stop+=+false;
++++++++++++new+PrintW().start();
++++++++}
++++}

++++static+class+PrintW+extends+Thread{
++++++++@Override
++++++++public+void+run(){
++++++++++++while(!stop){
++++++++++++++++TimerTest.delayOneSec("W");
++++++++++++}
++++++++}

++++}
}|code-block|syntax|javascript|2750501|任务本身将重复执行，耗时2秒或6秒。让我们看看每个场景的结果。|2750502|使用timer.schedule(task,+0,+5000);时，输出为TTWWWTTTTTTTTWWWTTTTTTTTWWWTTTTTTTT。如你所见，计时器遵循如下规则，如果任务及时完成，则等待period超时，如果当前任务持续时间超过period，则立即启动下一个任务。|offset|length|style|CODE|2750503|使用timer.scheduleAtFixedRate(task,+0,+5000);时，输出为TTWWWTTTTTTTTWWTTTTTTTTWWTTTTTTTTWWTTTTTTTTWWTTTTTTTTWWTTTTTTTT。现在情况有点不同了。javadoc|2750504|2750505|两次或两次以上的执行将快速连续发生，以“追赶”。|blockquote|2750506|2750507|2750508|在这里生效。正如您所看到的，忽略第一个TTWWW，每两个任务将打印TTTTTTTTWW，并持续10秒(两个周期)。|2750509|让我们深入研究一下Timer的源代码。|2750510|public+void+schedule(TimerTask+task,+Date+firstTime,+long+period)+{
++++if+(period+<=+0)
++++++++throw+new+IllegalArgumentException("Non-positive+period.");
++++sched(task,+firstTime.getTime(),+-period);
}


public+void+scheduleAtFixedRate(TimerTask+task,+long+delay,+long+period)+{
++++if+(delay+<+0)
++++++++throw+new+IllegalArgumentException("Negative+delay.");
++++if+(period+<=+0)
++++++++throw+new+IllegalArgumentException("Non-positive+period.");
++++sched(task,+System.currentTimeMillis()%2Bdelay,+period);
}|2750511|如您所见，在schedule方法中，period被转换为负值。让我们来看看在调度时有什么不同。|2750512|下面的代码在TimerThread的mainloop中。|2750513|currentTime+=+System.currentTimeMillis();
executionTime+=+task.nextExecutionTime;
if+(taskFired+=+(executionTime<=currentTime))+{
++++if+(task.period+==+0)+{+//+Non-repeating,+remove
++++++++queue.removeMin();
++++++++task.state+=+TimerTask.EXECUTED;
++++}+else+{+//+Repeating+task,+reschedule
++++++++queue.rescheduleMin(
++++++++task.period<0+?+currentTime+++-+task.period
++++++++++++++++++++++:+executionTime+%2B+task.period);
+++++++++++}
++++}
}|2750514|这就是魔术发生的地方，对于schedule方法，下一个任务的执行时间是基于在this任务运行之前计算的currentTime。这意味着，每个任务的执行时间只与前一个任务的开始时间相关。|2750515|entityMap^0|0|0|0|2|U|11|Z|2S|6|3D|6|0|2|15|1C|1R|0|0|0|0|0|J|5|X|A|0|9|5|0|0|6|8|I|6|0|6|B|I|8|0|0|D|8|1F|B|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1D|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1E|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|1F|8|@$K|1G|L|1H|M|N]|$K|1I|L|1J|M|N]|$K|1K|L|1L|M|N]|$K|1M|L|1N|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1O|8|@$K|1P|L|1Q|M|N]|$K|1R|L|1S|M|N]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|1T|8|@]|9|@]|A|$]]|$1|R|3|S|5|T|7|1U|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1V|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|1W|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1X|8|@$K|1Y|L|1Z|M|N]|$K|20|L|21|M|N]]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|22|8|@$K|23|L|24|M|N]]|9|@]|A|$]]|$1|10|3|11|5|D|7|25|8|@]|9|@]|A|$E|F]]|$1|12|3|13|5|6|7|26|8|@$K|27|L|28|M|N]|$K|29|L|2A|M|N]]|9|@]|A|$]]|$1|14|3|15|5|6|7|2B|8|@$K|2C|L|2D|M|N]|$K|2E|L|2F|M|N]]|9|@]|A|$]]|$1|16|3|17|5|D|7|2G|8|@]|9|@]|A|$E|F]]|$1|18|3|19|5|6|7|2H|8|@$K|2I|L|2J|M|N]|$K|2K|L|2L|M|N]]|9|@]|A|$]]|$1|1A|3|-4|5|6|7|2M|8|@]|9|@]|A|$]]]|1B|$]]

Thanks @Nizet's answer, I have written a sample code for some people who want to practice and learn.

<pre><code>import java.util.Timer;
import java.util.TimerTask;

public class TimerTest {

 public static void main(String args[]){
 TimerTest.DelayTask task = new DelayTask();
 Timer timer = new Timer();
 /**
 * Use schedule or scheduletAtFixedrate and check the printed result
 */
 timer.schedule(task, 0, 5000);
 //timer.scheduleAtFixedRate(task, 0, 5000);
 }

 public static boolean stop = false;

 public static void delayOneSec(String status){
 try{
 System.out.print(status);
 Thread.sleep(1000);
 }catch(Exception e){
 e.printStackTrace();
 }
 }

 static class DelayTask extends TimerTask{
 int count = 2;

 @Override
 public void run() {
 // TODO Auto-generated method stub
 stop = true;
 for(int i = 0; i &lt; count; i++){
 TimerTest.delayOneSec("T");
 }
 if(count == 2){
 count = 6;
 }else{
 count = 2;
 }
 stop = false;
 new PrintW().start();
 }
 }

 static class PrintW extends Thread{
 @Override
 public void run(){
 while(!stop){
 TimerTest.delayOneSec("W");
 }
 }

 }
}
</code></pre>

The task itself will repeat to take 2 seconds or 6 seconds. Let's see the result of each scenario. 

When using <code>timer.schedule(task, 0, 5000);</code>, the output is <code>TTWWWTTTTTTTTWWWTTTTTTTTWWWTTTTTTTT</code>. As you can see, the timer follow the rules like below, wait till <code>period</code> time outs if task finishes in time, launch next task immediately if current task lasts more than <code>period</code>.

When using <code>timer.scheduleAtFixedRate(task, 0, 5000);</code>, the output is <code>TTWWWTTTTTTTTWWTTTTTTTTWWTTTTTTTTWWTTTTTTTTWWTTTTTTTTWWTTTTTTTT</code>. Things are a little different now. The javadoc 

<blockquote>
 two or more executions will occur in rapid succession to "catch up."
</blockquote>

takes effect here. As you can see, ignoring the first <code>TTWWW</code>, every two tasks will print <code>TTTTTTTTWW</code> and it lasts 10 seconds(two periods). 

Let's dig into the source code of <code>Timer</code>.

<pre><code>public void schedule(TimerTask task, Date firstTime, long period) {
 if (period &lt;= 0)
 throw new IllegalArgumentException("Non-positive period.");
 sched(task, firstTime.getTime(), -period);
}


public void scheduleAtFixedRate(TimerTask task, long delay, long period) {
 if (delay &lt; 0)
 throw new IllegalArgumentException("Negative delay.");
 if (period &lt;= 0)
 throw new IllegalArgumentException("Non-positive period.");
 sched(task, System.currentTimeMillis()+delay, period);
}
</code></pre>

As you can see, the <code>period</code> is transferred to negative value in <code>schedule</code> method. Let's see what's the difference when scheduling it. 

The below code is in the <code>mainloop</code> of <code>TimerThread</code>, 

<pre><code>currentTime = System.currentTimeMillis();
executionTime = task.nextExecutionTime;
if (taskFired = (executionTime&lt;=currentTime)) {
 if (task.period == 0) { // Non-repeating, remove
 queue.removeMin();
 task.state = TimerTask.EXECUTED;
 } else { // Repeating task, reschedule
 queue.rescheduleMin(
 task.period&lt;0 ? currentTime - task.period
 : executionTime + task.period);
 }
 }
}
</code></pre>

It's where magic happens, for <code>schedule</code> method, the next task execution time is based on the <code>currentTime</code> which is calculated right before the this task runs. That means, every task's execution time only be related with previous task starts time.

What is the difference between these 2 methods of <code>Timer</code> class :

<pre><code>schedule(TimerTask task, long delay, long period)
</code></pre>

and

<pre><code>scheduleAtFixedRate(TimerTask task, long delay, long period)
</code></pre>

<a href="http://docs.oracle.com/javase/7/docs/api/java/util/Timer.html">Documentation</a> doesn't make the difference between them clear.

What is the difference between schedule and scheduleAtFixedRate?

Timer类的这两个方法有什么区别：schedule(TimerTask task, long delay, long period)和scheduleAtFixedRate(TimerTask task, long delay, long period)并没有清楚地说明它们之间的区别。

问schedule和scheduleAtFixedRate有什么区别？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问schedule和scheduleAtFixedRate有什么区别？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问schedule和scheduleAtFixedRate有什么区别？
EN