Exécution de N tâches à intervalles pseudo réguliers

Version imprimable

Bonjour

J'ai besoin de pouvoir exécuter un certain nombre de tâches en parallèle et chacune de ces tâches doit exécuter une action simple et rapide à intervalle presque régulier (par exemple entre 5s et 6s de délai).

Avec le code ci-dessous j'arrive à lancer plusieurs tâches en parallèle, mais chacune de ces tâches est exécutée à intervalle strictement régulier,
il n'y a pas de partie variable dans le délai.

Voyez-vous comment faire pour ajouter cette partie variable dans le délai d'exécution de chaque tâche ?

Merci
Code:

1 2 3 4 5 6 7 class Activator extends TimerTask { @Override public void run() { // do something } }
Code:

1 2 3 4 5 6 7 8 public static void main(String[] args) throws Exception { Timer timer = new Timer(true); timer.scheduleAtFixedRate(new Activator(), 0, 2000); // ici le délai devrait être compris entre 2000 et 2300 ms par exemple timer.scheduleAtFixedRate(new Activator(), 0, 5000); timer.scheduleAtFixedRate(new Activator(), 0, 7000); // ... } }

09/02/2016, 12h18
Invité

scheduleAtFixedRate() ça va être compliqué de lancer des tâches à des intervalles fixes variables en effet ;)
Ce que j'essaierai de faire, c'est de lancer la tâche suivante à la fin de l’exécution de la précédente tâche, comme ça tu peux fixer un délais différent.
Ce n'est peut-être pas la meilleure solution, en tout cas je ne pense pas que tu arrivera à tes fins en utilisant uniquement la méthode scheduleAtFixedRate()
09/02/2016, 14h37
Carhiboux

Utiliser la classe Random?

Regarde du coté de la méthode nextInt.
09/02/2016, 17h03
Eldergrim

Merci pour vos réponses.

Comme pour Carhiboux ça n'est pas clair, je reprécise :
Ce qui doit être variable c'est le délai entre chaque exécution d'une même tâche. Dans mon exemple je lance trois tâches, avec des délais fixes à 2000, 5000 et 7000 ms, mais ce que je voudrais c'est qu'à chaque exécution de chaque tâche le délai soit légérement différent. Par exemple pour la première tâche 2100, puis 2200, puis 2180, etc. Pour la deuxième 5075, puis 5123, etc.

Donc effectivement je ne pense pas y arriver juste avec scheduleAtFixedRate(). Mais comme je ne maitrise pas ces aspects je ne sais pas trop quelles autres classes utiliser.
Je vais voir si j'arrive à faire quelque chose avec l'idée de EyZox. Ca doit être faisable en annulant l'ordonnancement et en jouant sur le deuxième paramètre de la méthode plutôt que sur le dernier.
Je continue à chercher.

EDIT:
si ça peut intéresser quelqu'un, je pense qu'une solution se trouve ici : http://www.tutorialspoint.com/java/j...ad_control.htm.
Après quelques simplifications et quelques tests, j'arrive à faire ce que je veux. Je posterai un exemple de code un peu plus tard.

La solution la plus simple consiste effectivement à reprogrammer la tâche. Pour te simplifier le travail tu peux très bien créer un "ExecutorService" et un "wrapper" :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
class DelayedExecutorService<T extends Runnable & Delayed> implements AutoCloseable {
    ScheduledExecutorService executor;
    /* ... Constructeurs & co. */
 
    public void scheduleAtRate(final T task) {
        class ReschedulingTask implements Runnable {
            public void run() {
                task.run();
                executor.schedule(ReschedulingTask.this, task.getDelay(MILLISECONDS), MILLISECONDS);
            }
        }
        executor.schedule(new ReschedulingTask(), task.getDelay(MILLISECONDS), MILLISECONDS);
    }
}

10/02/2016, 11h54
Carhiboux
Citation:

Envoyé par Eldergrim

Comme pour Carhiboux ça n'est pas clair, je reprécise :
Ce qui doit être variable c'est le délai entre chaque exécution d'une même tâche. Dans mon exemple je lance trois tâches, avec des délais fixes à 2000, 5000 et 7000 ms, mais ce que je voudrais c'est qu'à chaque exécution de chaque tâche le délai soit légérement différent. Par exemple pour la première tâche 2100, puis 2200, puis 2180, etc. Pour la deuxième 5075, puis 5123, etc..

Ben Carhiboux il avait très bien compris. Et il persiste à te dire que la classe Random avec sa méthode nextInt devrait te convenir.

Tu me dis que tu veux pour la première tache, des valeurs aléatoires entre 2000 et 2300.

Donc si tu fais un truc du genre :
Code:

1 2 3 Random randomGen= new Random(); timer.scheduleAtFixedRate(new Activator(), 0, 2000 + randomGen.nextInt(300));
Tu vas avoir un délais entre 2000 et 2300 (exclu).
10/02/2016, 12h23
Invité
Citation:
Envoyé par Carhiboux

Ben Carhiboux il avait très bien compris. Et il persiste à te dire que la classe Random avec sa méthode nextInt devrait te convenir.

Tu me dis que tu veux pour la première tache, des valeurs aléatoires entre 2000 et 2300.

Donc si tu fais un truc du genre :

Code:

1 2 3 Random randomGen= new Random(); timer.scheduleAtFixedRate(new Activator(), 0, 2000 + randomGen.nextInt(300));

Tu vas avoir un délais entre 2000 et 2300 (exclu).
Il souhaite avoir un délais qui change entre chaque exécution de tâche, pas un délais de départ aléatoire qui va rester identique tout au long de l'exécution du timer.
10/02/2016, 13h04
Carhiboux
Je ne veux pas être désagréable, mais as tu essayé la solution que j'ai proposé avant de la critiquer et de la déclarer invalide?

Je ne pense pas, car elle est parfaitement fonctionnelle.

Si tu veux t'en assurer, tu peux essayer :
Code:

1 2 3 4 5 6 7 public static void main(String[] args) { for(int i = 0 ; i < 10; i++){ Random rand = new Random(); System.out.println("Val = " + rand.nextInt(300)); } }
Donne en sortie :
Code:

1 2 3 4 5 6 7 8 9 10 11 Val = 51 Val = 214 Val = 276 Val = 243 Val = 111 Val = 188 Val = 221 Val = 159 Val = 269 Val = 233
et à l’exécution suivante histoire de voir si les mêmes nombres reviennent toujours?
Code:

1 2 3 4 5 6 7 8 9 10 11 Val = 107 Val = 119 Val = 288 Val = 151 Val = 263 Val = 282 Val = 213 Val = 153 Val = 132 Val = 6
Donc je persiste et signe, Random et nextInt font parfaitement le boulot dans le cas proposé.

Quand bien même tu instancierait une nouvelle instance de Random à chaque appel au main, tu auras une valeur différente avec nextInt(n) comprise dans l'intervalle [0;n[. Cf l'exemple au dessus.

Je persiste et signe, Carhiboux semble ne pas avoir compris ;)
Mais je ne vous jette pas la pierre Pierre, la nuance est subtile.

Pour montrer ce que je voulais faire voici un exemple de code qui fonctionne :
(Tu noteras l'usage de la méthode nextInt(), et pas seulement pour te faire plaisir, car elle m'est tout à fait utile)

Est-ce plus clair maintenant ?

J'espère que cet épisode ne te dissuaderas pas de répondre à une de mes éventuelles futures question.

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
38
39
40
41
42
43
44
45
46
 
import java.util.Random;
 
class RunnableDemo implements Runnable {
	public int delay;
	public Thread t;
	private String threadName;
 
	RunnableDemo(String name, int delay) {
		this.threadName = name;
		this.delay = delay;
		System.out.println("Creating " + threadName);
	}
 
	public void run() {
		System.out.println("Running " + threadName);
		int delayLocal;
		try {
			for (int i = 10; i > 0; i--) {
				delayLocal = this.delay + new Random().nextInt(500);
				System.out.println("Thread: " + threadName + ", " + i + ", delay: " + delayLocal);
				Thread.sleep(delayLocal);
			}
		} catch (InterruptedException e) {
			System.out.println("Thread " + threadName + " interrupted.");
		}
		System.out.println("Thread " + threadName + " exiting.");
	}
 
	public void start() {
		System.out.println("Starting " + threadName);
		if (t == null) {
			t = new Thread(this, threadName);
			t.start();
		}
	}
}
 
public class TestThread {
	public static void main(String args[]) {
		RunnableDemo R1 = new RunnableDemo("Thread-1", 1000);
		R1.start();
		RunnableDemo R2 = new RunnableDemo("Thread-2", 3000);
		R2.start();
	}
}

10/02/2016, 13h34
Carhiboux
Si je n'ai pas compris, pourquoi à tu exactement utilisé la solution que j'ai proposé? Oo
Code:

1 2 delayLocal = this.delay + new Random().nextInt(500);
Après, tu es passé par des Threads au lieu des Timer de ton message initial, mais ce n'était pas ta question initiale qui était de savoir comment introduire un peu d'aléatoire dans ton code.

Mais bon, on va pas couper les cheveux en quatre, tu as ta solution, c'est le principal! :)
10/02/2016, 13h41
Eldergrim

Le point sur lequel je butais n'était pas de générer de l'aléatoire, c'était de faire varier à chaque passage dans la boucle le délai entre chaque execution d'une tâche.
Si tu as exécuté le bout de code que j'ai posté tu devrais voir ce que je veux dire.

Mais comme tu l'écris, on ne va pas couper les cheveux en quatre. D'ailleurs c'est pas facile.

Sur ce, je marque en résolu car effectivement le principal c'est que j'ai trouvé ma réponse.

Merci !