[Threads] Synchronisation

**InDaWinD** · 19/02/2006, 16h14

Bonjour,
J'ai un probleme de synchronisation de thread.
J'ai donc une class qui herite de thread.

cette classe possede
-une methode synchronized demandeImage().
-une methode run:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
public void run() {
        CamClass uneCam = (CamClass)mcc.vCam.getID(this.idCam);
        while(uneCam.getEnLecture()) {
            demandeImage();
            try {
                this.sleep(100);
            } catch(Exception e) {
                System.err.println("Impossible d'effectuer le sleep");
            }
 
        }
        System.out.println("Arret du thread");
    }

Vous l'aurez compris, tant que le thread est vivant, je fais une demande d'image, et ensuite je sleep 100ms.

C'est là que ça se complique. dans la methode demandeImage, j'envoie et recupere des données a partir d'une flux (InputStream et OutputStream).
Si je lance un seul thread, pas de probleme. Si j'en lance 2 ou + les thread font des demandeImages(), simultanement. De ce fait il récupere des octets qui ne leurs sont pas déstiné etc etc...

Je voudrais donc savoir comment faire pour que, quand un thread appelle la methode demandeImage, tous les autres threads attendent, une fois demandeImage terminé, le thread se met en wait, et permet a un autre thread d'appeler demandeImage()... etc etc.

J'ai essayé avec notifyAll() et wait(), mais je ne suis arrivé a rien...

Merci de vos lumieres

**ego** · 19/02/2006, 16h36

Il faut en fait synchronizer les threads sur une même ressource.
Le synchronized évite que la même opération d'un objet soit appelée de manière concurrentielle mais cela n'évite pas, si tu exécutes plusieurs objets d'appeler la même opération sur ces instances !
En fait, dans ton cas, la ressource critique étant visiblement ton stream, tu ne le protèges pas en faisant ce que tu fais actuellement.

Tu peux donc, dans ta méthode demandeImage faire :

Code :

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

1
2
3
synchronized (MaClasse.class) {
   <appel à ton stream ici>
}

MaClasse étant le nom de la classe de l'objet qui a l'opération demandeImage.
Tu peut remplacer aussi le "MaClasse.class" par l'objet représentant ton stream si la référence est la même pour tous les threads que tu lances.

Tu peux aussi regarder le pattern "Guard" et si tu utilises le JDK1.5, le package java.util.concurrent

**Scorpyosis** · 19/02/2006, 16h39

tu peux commencer par declarer ta methode demandeImage() en synchronized, comme ca chaque Thread fera l'un après l'autre l'appel a cette méthode.

Ceci te permettra de ne pas avoir d'octets allant au mauvais Thread, par contre ca ne garantira pas surtout si tu as beaucoup de Thread qu'ils se partageront equitablement la ressource, par exemple si tu as 3 thread tu peux avoir un comportement du type :

t1 marche - t2,t3 attendent
t1 a fini
t2 marche - t1,t3 attendent
t2 a fini
t1 marche - t2,t3 attendent
....

**InDaWinD** · 19/02/2006, 16h47

Je ne suis pas sur d'avoir bien compris.

Dans le constructeur de mon thread, je lui file le socket en parametre sur lequel j'effectue les echanges.

Code :

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

1
2
3
4
5
//flux d'ecriture
            this.fluxSortie = new DataOutputStream(new BufferedOutputStream(sck.getOutputStream()));
 
            //flux de lecture
            this.fluxEntree = new DataInputStream(new BufferedInputStream(sck.getInputStream()));

sck étant le socket passé en parametre.

Il faudrait donc qu'a l'interieur de ma méthode demandeImage() je fasse

Code :

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

1
2
3
4
5
 
synchronized (this.fluxEntree, this.fluxSortie) {
   < Et ici je fait tout mon traitement 
   comme this.fluxEntree.read() etc etc > ???
}

Pour Scorpyosis, m'a méthode demandeImage est deja déclaré synchronized mais ils appelle pourtant la méthode en même temps.

Code :

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

public synchronized void demandeImage() {

[/quote]

**ego** · 19/02/2006, 17h01

Comme je ne savais pas exactement comme tu lisais...
La solution est donc de se synchronizer sur l'objet "class"
Ex :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
public class MonDemandeurImage {
 
    public MonDemandeurImage (Socket sck) {
          ....
    }
 
    public void demandeImage() {
         synchronized(this.getClass()) {
                .... manipulation de test streams......
         }
    }
}

**InDaWinD** · 19/02/2006, 17h13

Un grand merci !!! Cela a l'air de fonctionné

Par contre j'ai pus voir comme le disait Scorpyosis que les threads n'onts pas forcement la meme probabilité d'etre executé.

Un thread est plus executé que l'autre, il y'a une methode simple pour contrer ce petit probleme ?