Synchronized mal compris ou HS?

Version imprimable

19/10/2010, 14h10
flotho

Synchronized mal compris ou HS?

Bonjour à tous,

Voici le contexte :
J'ai un dev en cours qui nécessite une captation d'image par 2 webcams. Celles ci ne peuvent être lues simultanément donc j'ai un accès concurrentiel.
Je prends le temps de lire les FAQ et Tuto sur les thread et la synchronisation.
Je développe et cela ne fonctionne pas comme je l'imagine. je me pose des questions, cherche, discute avec le dev de l'API que j'utilise (v4l4j) il me dit que ma synchro n'est pas correcte. Je vérifie, re regarde, relis...
Et je finis par tester tout simplement le tuto synchro et là PAF: En ajoutant la clause synchronized cela ne fonctionne pas comme proposé dans le tuto.

MA QUESTION :
Est ce normal que ce dernier test échoue ou bien y a t il quelque chose de spécial à activer dans la JVM pour que cela fonctionne?

Un grand merci d'avance à vous car je dois dire que plus basique on peut pas faire et que j'en perds mes cheveux.
19/10/2010, 14h19
dinobogan

Sans code, c'est compliqué de te suivre... Peux-tu illustrer le problème par un petit programme ?

Bien sûr,

j'ai simplement utilisé cela :

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
47
48
49
50
51
52
53
54
/*
/**
 * @author Valère VIANDIER
 *
 */
public class VaseComuniquant {
    private static final int QUANTITE_INITIALE = 200;
    private static final int NB_THREAD_MAX = 2;
 
    private static int iteration = 0;
 
    private int[] vase = {QUANTITE_INITIALE / 2,QUANTITE_INITIALE / 2};
 
    public VaseComuniquant() {
        for( int i = 0; i < NB_THREAD_MAX; i++)
            new ThreadTransfert().start();
    }
    public static void main(String[] args) {
        new VaseComuniquant();
    }
 
    public synchronized int transfert(int qte) {
        // Ne pas enlever les System.out de ce test !
        System.out.print("-("+qte+") dans le vase 1 ");
        vase[0] -= qte;
        System.out.println("+("+qte+") dans le vase 2");
        vase[1] += qte;
        iteration++;
        if( iteration % 1000 == 0)
            System.out.println("\n" + iteration + " ITERATIONS.\n");
        return vase[0]+vase[1];
    }
 
    public class ThreadTransfert extends Thread {
        Random r = new Random();
        int quantite;
        @Override
        public void run() {
            while( !isInterrupted()) {
                quantite = r.nextInt(11)-6;
                vase[0] -= quantite;
                vase[1] += quantite;
                if( transfert(quantite) != QUANTITE_INITIALE) {
                    System.err.println("Quantité totale invalide à l'itération " + iteration);
                    System.exit(-1);
                }
 
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {}
            }
        }
    }
}

Directement depuis le tuto de Valère.
Sauf que d'après le tuto je ne devrais jamais avoir d'erreur de vase communiquant.
Or j'ai toujours un problème avec le synchronized. Problème au sens que l'algorithme ne devrait pas s'arrêter.
Donc j'ai l'impression que soit j'ai rien compris au synchronized, soit je sais plus écrire, soit y'a une grosse anguille sous roche.

19/10/2010, 14h37
dinobogan

Le programme a un problème. Les Thread modifient les données du tableau "vase" sans synchronisation juste avant d'appeler la méthode "transfert".
19/10/2010, 14h41
thelvin
Il y a manifestement une erreur dans ce tuto.

Les lignes :
Code:

1 2 vase[0] -= quantite; vase[1] += quantite;
ne devraient apparaître que dans le code synchronisé, pas ailleurs.
19/10/2010, 14h45
flotho

Ca me rassure.

Mais ce que je ne comprends pas c'est que
vase[0] -= quantite;
vase[1] += quantite;
sont dans une méthode synchronisée.
Donc normalement les threads ne devraient pas accéder simultanément à cette méthode.
Donc il ne devrait pas y avoir de problème?

Où est ce que je me trompe là?
19/10/2010, 14h49
dinobogan

Chaque Thread modifie d'abord les données du tableau "vase" avant d'appeler la méthode synchronisée.
Le problème ne vient pas de la méthode "transfert", mais de la modification en dehors de tout bloc synchronisé de "vase".

1 pièce(s) jointe(s)

Ok vu, c'est dans le run que cela pose problème.

Maintenant que je suis rassuré sur le fonctionnement du tuto, cela m'amène à mon problème particulier. En PJ ma classe qui pose problème.

L'appel se fait de la façon suivante :
Code:

1 2 3 4 5 rectoWebcam = new Webcam(rectoDevice, 1, 640, 480, workPath, "Recto"); versoWebcam = new Webcam(versoDevice, 1, 640, 480, workPath , "Verso"); rectoWebcam.start_Webcam(); versoWebcam.start_Webcam();
Je ne dois pas accéder simultanément à la capture d'une image au risque de saturer le bus USB et de renvoyer une erreur.
J'ai donc l'impression qu'il me manque des synchronized par ci par là.
Pourriez vous m'expliquer mon erreur?

Salut,

Ton code est bien synchronisé, mais sur un lock d'instance :
Code:

1 2 3 4 5 synchronized void capture_frame() throws V4L4JException { this.fg.startCapture(); this.bb = fg.getFrame(); this.fg.stopCapture(); }
Ce qui équivaut en fait à ceci :
[code]
Code:

1 2 3 4 5 6 7 void capture_frame() throws V4L4JException { synchronized (this) { this.fg.startCapture(); this.bb = fg.getFrame(); this.fg.stopCapture(); } }
Mais vu que tu manipules deux instances différentes, cela revient à avoir deux synchronisations sur deux locks différents : synchronized(rectoWebcam) et synchronized(versoWebcam).

:arrow: Les deux synchronisations sont totalement distinctes, et ne se bloque pas manuellement. En fait cette synchronisation t'empêche uniquement d'appeler la méthode capture_frame() de la même instance depuis deux thread différents, mais elle ne t'empêche pas d'appeler plusieurs fois cette méthode sur des instances différentes (ce qui est ton cas).

Pour éviter ce genre de problème, il est préférable de définir explicitement un lock unique pour toutes les instances :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 /** * On utilise un attribut static comme lock. */ private static final Object CAPTURE_LOCK = new Object(); void capture_frame() throws V4L4JException { synchronized (CAPTURE_LOCK) { this.fg.startCapture(); this.bb = fg.getFrame(); this.fg.stopCapture(); } }
Désormais le code de la méthode capture_frame() ne pourra pas du tout être exécutée en parallèle, même si on manipule plusieurs instances...

a++

19/10/2010, 15h24
flotho

OOOOKKKKKK!!

J'avais mal assimilé le fait que le simple synchronized était pour le même thread mais plusieurs instances.

Si j'ai bien compris, si je veux travailler sur du multithread et du synchronized, il faut que je passe avec un :

Code:

static final mon_gardefou

. Est ce bien cela?

Maintenant je me rends compte que cela est quand même bien lent en terme de traitement.
Les sémaphores sont ils une solution?
Y'en a t il une autre plsu simple/efficace.

Merci de tous vos commentaires de qualité!!
19/10/2010, 15h27
adiGuba

Citation:

Envoyé par flotho

Maintenant je me rends compte que cela est quand même bien lent en terme de traitement.

Ben... Si tu veux réellement une seule exécution à la fois, je ne vois pas comment tu pourrais faire plus rapide...

a++

J'ai une dernière question,

Sur l'exemple que j'ai posté, comment faire pour que la méthode stop_webcam ne soit pas accessible s'il y a une capture et/ou un enregistrement en cours?

Suffirait il de reprendre
Code:

1 2 3 4 5 6 7 public void stop_webcam() { synchronized (CAPTURE_LOCK) { this.actif = false; this.vd.releaseFrameGrabber(); this.vd.release(); } }