Newsgroup: it.comp.java
Titolo: non capisco la sincronizzazione dei thread

aiuto, non ci capisco niente.
provo a spiegare.
ho due classi, a e b, che vengono eseguite parallelamente. ci sono
tantissime istanze di a e di b, e tutte leggono e scrivono in un array di
oggetti, c, e dovrebbero farlo in mutua esclusione.
in pratica ho adottato questa implementazione
class a{
    void metodo1{
        synchronized (c){leggi/scrivi c}
    }
}
class b{
    void metodo2{
        synchronized (c){leggi/scrivi c}
    }
}
metodo1 e metodo2 hanno funzioni differenti.
ora mi pare di capire che manchi qualcosa. avendo messo la clausola
synchronized quando un'istanza di a o di b arriva al blocco critico le altre
che ci arrivano dopo si fermano correttamente (tra l'altro, essendo c un
array di oggetti, io metto il lock solo sul singolo elemento di c usato,
quindi sarebbe synchronized (c[1]), ad esempio), ma sembrano non riprendere
mai l'esecuzione.
ora, mi pare di capire che quando si dichiarano dei metodi synchronized si
debba mettere un wait() e che l'esecuzione riprende a seguito di un notifiy
o notifyAll, non č che manca qualcosa del genere nei miei blocchi
synchronized?
il problema č che tutti gli esempi che ho trovato io, ma non sono molto
bravo a cercare, si limitano a dire synchronized (nomevariabile){opportuno
codice}... grazie, se sapessi l'opportuno codice non avrei bisogno di un
esempio ^_^
scusate se forse non sono stato chiaro, se manca qualche elemento chiedete e
vedrņ di rispondere per quelle che sono le mie capacitą.
grazie a tutti per le risposte
swift

 esempio ^_^
Qui puoi trovare degli esempi:
Threads: Doing Two or More Tasks At Once
http://java.sun.com/docs/books/tutorial/essential/threads/
Qui c'è un intero libro. Il capitolo 13 parla della concorrenza.
Thinking in Java, 3rd Edition
http://www.mindview.net/Books/TIJ/
(Il tutto è in inglese. "Thinking in Java" è stampato anche in italiano.)
Gaetano

 Qui puoi trovare degli esempi:
purtroppo avevo già guardato quei 2 link, ma non sono riuscito a capire lo
stesso :(
cmq ancora grazie
swift

 messe :)
allora l'unica cosa che mi viene in mente è che diversi thread tentino 
di acquisire le risorse in ordine inverso, ovvero ad esempio:
- il thread T1 cerca di acuisire prima il lock L1 e poi il lock L2
- il thread T2 cerca di acuisire prima il lock L2 e poi il lock L1
Questo può generare deadlock. In questo caso la soluzione è dare un 
ordine agli oggetti su cui si deve fare lock e poi rispettare questo 
ordine. Nel tuo caso l'ordine da utilizzare c'è già perché gli oggetti 
sono dentro ad un array.
Può essere questo?
Gaetano

> Può essere questo?
temo di no... ogni thread prende il controllo di un solo oggetto per
volta... non ci può essere deadlock, devono solo fermarsi e aspettare che
l'altro abbia finito con un oggetto solo... non capisco :(
cmq grazie dell'aiuto
swift


Faccio un post un po del c***
a volte quando non se ne viene fuori bene con la concorrenza, conviene
ristudiare da capo le classi, i metodi e in particolare il Monitor.
Anziche "synchrionizzare" sulla variabile c
potresti pensare ad un unico metodo synchronyzed tipo
synchrronized void UseC(String aOperation, ...)
di una classe myMonitor
che im base aal valore di aOperation puo' scrivere o leggere sulla variabile
c in modo certamente esclusivo senza causare DLock
cya
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/