Discussion :

[flotho]

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.

[dinobogan]

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

[flotho]

Bien sûr,

j'ai simplement utilisé cela :

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
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.

[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".

[thelvin]

Il y a manifestement une erreur dans ce tuto.

Les lignes :

Code :

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

1
2
vase[0] -= quantite;
vase[1] += quantite;

ne devraient apparaître que dans le code synchronisé, pas ailleurs.

[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à?

[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".