PROGRAMMAZIONE CONCORRENTE, DA PAG 84 A PAG 96
COMUNICAZIONI TRA THREAD
La programmazione java permette la comunicazione tra thread. Un thread può comunicare agli altri
thread che un evento si è verificato e rendere in questo modo efficiente la sincronizzazione tra i
thread (si può così evitare l'inefficiente utilizzo del polling, ovvero la continua interrogazione dello
stato di una variabile per capire se un evento si è verificato, cosa che impegna la CPU a vuoto
finchè non si verifica l'evento).
La comunicazione tra thread in java si basa su 3 metodi:
• wait ( ): fa uscire il thread dal monitor (che in java è implicito, non visibile e realizzato
semplicemente anteponendo la keyword synchronized ai metodi che sono sezioni critiche
del programma) e lo sospende finchè un altro metodo entra nel monitor ed esegue il metodo
notify ( )
• notify ( ); attiva il primo thread che ha eseguito una wait sullo stesso oggetto
• notify ( ) all: attiva tutti ithread che hanno eseguito un thread sullo stesso oggetto. Il thread
con la priorità più alta viene mandato in esecuzione per primo.
ESEMPIO PRODUTTORE-CONSUMATORE
Scrivere un programma che utilizza la sincronizzazione tra thread in cui il produttore mette (scrive) un
dato in una locazione di memoria (buffer) e il consumatore lo prende (legge). Si deve garantire il
corretto alternarsi di scrittura e lettura per evitare duplicazioni o perdite di dati.
Per ottenere ciò scriviamo una classe Buffer con un attributo (unDato: il dato che viene scambiato)
e due metodi, che chiamiamo metti( ) e prendi( ). I due metodi scrivono e leggono un solo dato
alla volta. Essi devono essere sincronizzati (sincronyzed) in modo da non poter essere interrotti da
nessun altro thread quando scrivono o leggono. Inoltre, occorre che i due metodi:
• notifichino (notify) l'avvenuta scrittura o lettura in modo da sincronizzare produttore e
consumatore.
• Si sospendano (wait) e non scrivono o leggono un altro dato finché non arriva la notifica
relativa rispettivamente alla lettura del dato precedente o alla scrittura del nuovo dato.
La classe Produttore è costituita da un costruttore che usa un oggetto della classe Buffer ( che
chiamiamo buffer), genera un thread figlio ed invoca il metodo metti ( ) che scrive un dato
nell'oggetto buffer. L'invocazione è fatta in un ciclo for in modo da scrivere n dati. Per ogni
iterazione (ovvero per ogni scrittura di un dato) il metodo metti ( ) scrive un dato, poi sospende se
stesso (wait) e si riattiva solo quando si verifica il notify sullo stesso oggetto buffer (cosa che farà
il consumatore quando avrà letto il dato)
La classe Consumatore è costituita da un costruttore che usa lo stesso oggetto buffer, genera anche
lui un thread figlio ed invoca il metodo prendi ( ) che legge il dato dall'oggetto buffer. Anche in
questo caso l'invocazione è fatta in un ciclo for in modo da leggere gli n dati che vengono scritti dal
produttore. Per ogni iterazione (ovvero per ogni lettura di un dato) il metodo prendi ( ) legge un
dato, poi sospende se stesso (wait) e si riattiva solo quando si verifica il notify sullo stesso oggetto
buffer (cosa che farà il produttore quando avrà scritto il nuovo dato)
Infine la classe Principale (con il main) dopo aver creato l'oggetto ilBuffer, crea un oggetto
produttore che richiede come parametro di ingresso l’oggetto buffer, e un oggetto consumatore
che richiede anch'esso come parametro d’ingresso lo stesso oggetto buffer. Quando sarà eseguita
questa classe Principale, verranno creati i due oggetti produttore e consumatore che cominceranno
a scambiarsi i dati.
