Discussion :

[nabila.abdessaied]

salut,
je veux implémenter ça
une classe qui modélise un évènement appelé event
cette classe implémente ces deux méthodes :waiting() and wakeup()
nous avons juste un seul event et plusieurs thread qui partagent ce même évènement
et on a un seul thread qui va notifier ces threads qui attendent
il va faire wakeup de event alors tous les thread sortent de waiting

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
class a {
public int a;=0;
event e=new event();
public a(){
callThread(); //creation thread 1
callThread(); //creation thread 2
callThread(); //creation thread 3
callThread(); //creation thread 4
callThread(); //creation thread 5
.
.
//nombre indefini de thread qui font le wait cad c pa statique on ne le sait pas
.
.
//ce thread va notifier tous les autre thread
new Thread (){
run(){
a=5;
e.wakeup()
}}.start();
}
 
//cette methode va creer un thread qui va attendre la notification de l//'evenement avant
//et apres il va afficher le contenue de a
private void callThread(){
new Thread (){
run(){
e.waitng();
System.out.println(a);
}}.start();
}

normalement tous les thread ne vont pas afficher le contenu de a que après la notification
mon problème c'est que dans cet exemple il y a un seul qui peut voir la notification
et sort de la phase de d'attente
parce que la notification fait le flag vaut true donc un seul tient compte de cette modification et sort de wait et modifient le flag a false donc les autres ne tiennent pas compte de cette modification et restent dans l'attente infinie
voila la classe event

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
public final class Event {
/**
* variable used to store the notification if it takes place
* before being expected
*/
private boolean status = false;
 
public final synchronized void waiting() {
while (status == false ) {
try {
wait();
}
catch (InterruptedException e) {
}
}
status = false ;
}
// notify all waits on this event
public final synchronized void wakeUp() {
status = true;
notifyAll();
}
 
 
}

après j'ai eu cette idée c'est de créer dans la classe event un tableau d'évènement
si un thread veut entrer dans waiting il va créer un nouveau évènement et le store dans le tableau et ensuite il fait le wait sur cet évènement
après si le thread de notification envoi la notification il va faire ce qui suit notifier tous les évènements de tableau
mais il reste un souci
c'est que on sait jamais si on fait tout les wait avant d'envoyer la notification
par exemple si on a 60 thread qui vont entrer en wait
il y a seulement 30 qui entrent
après la notification aura lieu
donc notification de tous les élément de tableau c'est à dire 30 thread seront notifiées et les autres même si il vont entrer après en wait il n'y a aucun thread qui va faire la notification
donc si je sais pas le nombre de thread qui vont faire le wait
comment je peux empêcher le thread qui envoie la notification d'envoyer la notification avant que tous les thread ont effectué les wait ?

merci de me répondre