Discussion :

[storm_2000]

Bonjour,

j'aimerai avoir votre aide dans le cadre de la programmation concurrente.
En effet, j'ai bcp de mal à comprendre le principe de fonctionnement
du synchronised(monObject)...
Voilà les deux portions de codes

Code :

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

1
2
3
4
5
6
7
8
9
10
 
        /* Pourquoi faire une double synchronisation et mutex2.notify() ? vue...*/
        synchronized(mutex)
        {
            synchronized(mutex2)
            {
                // CODE 
                mutex2.notify();
            }
        }

Code :

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

1
2
3
4
5
6
7
 
        /* ici, nous allons bloquer le code mais comment faire pour faire un appel a mutex.notify() pour le débloquer ? en effet, quand je fait l'appel j'ai une exception*/
            synchronized(mutex)
            {
                // CODE 
                mutex.wait();
            }

Merci de vos explicaitons...

[tchize_]

chaque "synchronized" est une barrière, qui empeche d'autre d'exécuté du code sur la même barrière. Pourquoi deux? parce que la première barrière protège tes flags (empeche que deux threads les tripottent en même temps) et la deuxième acquiert le flag mutex2 (opération obligatoire pour pouvoir le notifier). Ca réveillera un thread au hasard qui est bloqué par mutex2.wait(). Le synchronized englobant n'est pas nécessaire, son utilité dépend de ce que tu fais dans le bloc en question.


Quand à ton exception, c'est probablement que t'as pas mis le synchonized autour du notify

[storm_2000]

je manipules un List qui n'est pas synchronisé... Mais ne serait-il pas plus propre de faire ca avec des semaphores et des objets Lock

[adiGuba]

Salut,


Le plus simple serait d'utiliser Collections.synchronizedList() pour obtenir une List synchronizé (via des synchronized).

Les Locks simple ne sont qu'une version "objet" de synchronized et ne t'apporteront rien de plus...

Quand aux Semaphores je les ai quasiment pas utilisé mais je ne pense pas que cela puisse t'apporter grand chose...


Par contre si u as beaucoup d'accès en lecture sur ta liste pour peu de modification, tu pourrais peut-être te tourner vers les ReadWriteLock. Grosso modo tu protèges tous les accès en écriture sur ta liste (ajout/suppression d'éléments) via le "writeLock", et tu fais tous les accès en lecture via le "readLock".

L'intérêt c'est que s'il ne peut y avoir qu'un thread qui utilise la liste lors d'une écriture, il peut au contraire y en avoir plusieurs qui l'utilise en lecture

a++

[storm_2000]

le type List m'est imposé par l'exercice... nous n'avons pas le droit d'utiliser des listes déjà synchronisée...

merci de ta réponse