Discussion :

[oumay]

Bonjour,

J'ai une méthode qui cherche les agents disponibles pour réaliser des tâches, donc j'ai stocké l'état de chaque agent dans un tableau. Si je constate que l'agent est disponible alors je l'affecte à une tâche, sinon je lui envoie un message toutes les 5 ms pour mettre à jour son état

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
public void réaliser_tache() {
 
    boolean trouve = false;
 
    int j = 0;
 
    for (int i = 0; i < nbre_taches; i++) {
 
        while (j <= nbre_agents && trouve) {
 
            if (liste_agent.get(j).get_dispo() == true) {
 
                trouve = true;
 
            } else {
 
                j++
            }
        }
 
        if (trouve == true) {
 
            liste_tache.set(i, liste_agent.get(j).get_agent())
 
            trouve = false;
 
        }  else {
 
             // chercher agent disponible...
        }
    }
}

Je cherche faire en sorte d'envoyer un message aux agents qui ont répondu par liste_agent.get(j).get_dispo() == false (agent n'est pas dispo). Cet appel se répète toutes les 5 ms et il s'arrête s'il y en a un parmi eux qui est disponible pour réaliser la tâche en question (indice i).

Quelqu'un saurait-il m'indiquer comment faire ?

Merci d'avance pour votre aide.

[kolodz]

Bonjour,

Tu peux réaliser un traitement répétitif via un Timer. Cependant, 5ms est une période de temps très courte. Et cela me semble beaucoup trop bas comme valeur pour un Timer. Cela veut dire que tu veux que ta tâche soit réalisée 200 fois par seconde !

Tu peux lire la documentation sur les Timer ici : http://docs.oracle.com/javase/7/docs...ing/Timer.html

Voici ce que ça peux donner :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
package org.k.developpez.forum;
 
import java.util.Timer;
import java.util.TimerTask;
 
public class DemoTimer {
    static int nbtrigger = 0;
 
    public static void main(String[] args) {
        int delay = 1000; // milliseconds délai avant le premier trigger
        long period = 50; // milliseconds delta entre deux trigger
        final Timer timer = new Timer();
        TimerTask task = new TimerTask() {
 
            @Override
            public void run() {
                System.out.println("go timer !");
                nbtrigger++;
                if (nbtrigger > 100) {
                    timer.cancel();
                }
            }
        };
 
        timer.schedule(task, delay, period);
    }
}

Par contre, cela est asynchrone par rapport à ton Thread courant.

Une version beaucoup plus simpliste est d'ajouter un sleep dans une boucle :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
package org.k.developpez.forum;
 
public class DemoTimer {
 
    public static void main(String[] args) throws InterruptedException {
        int delay =500;
        while (true) {
            Thread.sleep(delay);
            System.out.println("go while");
        }
    }
}

Par contre, il y a une différence de comportement entre un sleep et un schedule avec une période. En effet le sleep va mettre en pause le thread courant pendant une durée X. Alors que le schedule va déclencher le comportement tous les X. Si le comportement est assez long cela se remarque.

Exemple :
Traitement de 1 sec
Délai de 2 sec
Traitement affiche le temps de début du traitement :

0 sec
3 sec
6 sec

0 sec
2 sec
4 sec
6 sec

Encore une fois fait très attention, les boucles d'attente active sont toujours une très mauvaise idée. Cela consomme énormément de ressources pour rien (même avec un timer ou un sleep), en particulier quand tu as un délai de rafraichissement de 5ms !

Cordialement.