scheduleAtFixedRate () vs scheduleWithFixedDelay ()

Version imprimable

tout dans la question. je n'arrive pas à faire la différence entre ces deux méthodes:
scheduleAtFixedRate (Runnable, long initialDelay, long period, TimeUnit timeunit)
scheduleWithFixedDelay (Runnable, long initialDelay, long period, TimeUnit timeunit)
exemple:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(2);
         System.out.println("Current Time = " + new Date());
        for (int i = 0; i < 3; i++) {
            Thread.sleep(1000);
            Runnable runnable = () -> {
                System.out.println(Thread.currentThread().getName() + " Start. Time = " + new Date());
                processCommand();//Thread.sleep(5000);
                System.out.println(Thread.currentThread().getName() + " End. Time = " + new Date());
            };
            scheduledThreadPool.scheduleWithFixedDelay(runnable, 1,2, TimeUnit.SECONDS);
        }

15/02/2015, 00h55
plawyx

scheduleWithFixedDelay(Runnable, long initialDelay, long period, TimeUnit timeunit)

après le délai initial, lancement d'une tâche, puis fin de la tâche, puis période, puis lancement d'une nouvelle tâche, puis fin, puis période, etc.........

scheduleAtFixedRate (Runnable, long initialDelay, long period, TimeUnit timeunit)

après le délai initial, lancement d'une tâche toutes les périodes (que la tâche précédente soit terminée ou non)
15/02/2015, 07h34
tchize_

Le premier, si tu dis toutes les 5 minutes, ce sera toutes les 5 minutes, depuis le point de départ. Donc

12:01 départ
12:06
12:11
12:16
...

Le second, c'est un délai entre tâche qui est compté. Donc si ta tâhce met 2m30 pour s'exécuter et que tu donne un délai de 5 minutes, tu aura

12:01 départ. Fin à 12:03.30
12:08.30
12:15
12:22.30
....

merci infiniment;
voici le code complet:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
 
public class Tache {
    private void processCommand() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            System.out.println(e.getMessage());
        }
    }
 
    void go() throws InterruptedException {
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(1);
         System.out.println("Current Time = " + new Date());
        for (int i = 0; i < 3; i++) {
            Thread.sleep(1000);
            Runnable runnable = () -> {
                System.out.println(Thread.currentThread().getName() + " Start. Time = " + new Date());
                processCommand();
                System.out.println(Thread.currentThread().getName() + " End. Time = " + new Date());
            };
            scheduledThreadPool.scheduleAtFixedRate(runnable, 1,2, TimeUnit.SECONDS);
        }
        Thread.sleep(10000);
        scheduledThreadPool.shutdown();
        while (!scheduledThreadPool.isTerminated()) {   }
        System.out.println("Finished all threads");
 
    }
 
    public static void main(String[] args) throws  InterruptedException {
        new Tache().go();   }
}

scheduleAtFixedRate (): output

Code:

1
2
3
4
5
6
7
8
9
10
11
 
run:
Current Time = Sun Feb 15 10:29:08 WAT 2015
pool-1-thread-1 Start. Time = Sun Feb 15 10:29:10 WAT 2015
pool-1-thread-1 End. Time = Sun Feb 15 10:29:15 WAT 2015
pool-1-thread-1 Start. Time = Sun Feb 15 10:29:15 WAT 2015
pool-1-thread-1 End. Time = Sun Feb 15 10:29:20 WAT 2015
pool-1-thread-1 Start. Time = Sun Feb 15 10:29:20 WAT 2015
pool-1-thread-1 End. Time = Sun Feb 15 10:29:25 WAT 2015
Finished all threads
BUILD SUCCESSFUL (total time: 17 seconds)

scheduleWithFixedDelay (): output

Code:

1
2
3
4
5
6
7
8
9
10
11
 
run:
Current Time = Sun Feb 15 10:28:00 WAT 2015
pool-1-thread-1 Start. Time = Sun Feb 15 10:28:02 WAT 2015
pool-1-thread-1 End. Time = Sun Feb 15 10:28:07 WAT 2015
pool-1-thread-1 Start. Time = Sun Feb 15 10:28:07 WAT 2015
pool-1-thread-1 End. Time = Sun Feb 15 10:28:12 WAT 2015
pool-1-thread-1 Start. Time = Sun Feb 15 10:28:12 WAT 2015
pool-1-thread-1 End. Time = Sun Feb 15 10:28:17 WAT 2015
Finished all threads
BUILD SUCCESSFUL (total time: 17 seconds)

chaque tache prend 5 secondes; la période = 2; delaiInitial=1; la taille du pool = 1;
l'affichage donne l'impression qu'il n'y' pas de différence entre les deux méthodes. est ce que vous étes d'accord!?

Déjà le fixed rate ne peut pas marcher correctement avec ta config. Ta tâche met 5 secondes, tu l'exécute toutes les 2 secondes (en tout cas c'est ce que tu demande), donc tu peux avoir jusque 3 taches en même temps mais.... tu ne lui a donné qu'un Thread. Tout ce qu'il peut faire c'est démarrer immédiatement la suivante.
Ensuite, tu ne demande pas de afire une tâche toutes les deux secondes, mais 3 tâches (tu ajoute 3 runnable), toujours avec un seul Thread. Du coup le fixedDelay est coincé aussi:

La tâche 1 est fini, après 2 secondes il devra la relancer. MAIS il est en retard pour la tâche 2 qui aurait du commencer 5 secondes plus tôt, ainsi que la 3. Du coup, il les lance, l'une après l'autre car il n'a qu'un thread.

Pour résumer, ta cofig nécessiterait pour tourner 3 threads pour le fixedDelay, et 9 thread pour le fixedRate, sinon on ne peut pas respecter les contraites. Voilà un code plus simple à comprendre:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 import java.util.Date; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; public class Tache { private void processCommand() { try { Thread.sleep(5000); } catch (InterruptedException e) { System.out.println(e.getMessage()); } } void go() throws InterruptedException { ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(9); System.out.println("Current Time = " + new Date()); for (int i = 0; i < 3; i++) { final int numeroTache = i; Runnable runnable = () -> { System.out.println(Thread.currentThread().getName() +"Tâche "+numeroTache + " Start. Time = " + new Date()); processCommand(); System.out.println(Thread.currentThread().getName() + "Tâche "+numeroTache + " End. Time = " + new Date()); }; scheduledThreadPool.scheduleAtFixedRate(runnable, 1,2, TimeUnit.SECONDS); // scheduledThreadPool.scheduleAtFixedDelay(runnable, 1,2, TimeUnit.SECONDS); } Thread.sleep(60000); scheduledThreadPool.shutdown(); while (!scheduledThreadPool.isTerminated()) { } System.out.println("Finished all threads"); } public static void main(String[] args) throws InterruptedException { new Tache().go(); } }

15/02/2015, 13h57
win_ubuntu

merci infiniment; maintenant, je sais bien faire la différence entre les deux méthodes.