Come si crea un thread. Thread in Java. Altro modo di creare un thread. Come si crea un thread

Transcript

1 Thread in Java Come si crea un thread Una applicazione Java che usa i thread può eseguire più attività contemporaneamente. Esempio: aggiornare l'informazione grafica sullo schermo e accedere alla rete. Ad esempio, quando un main crea una finestra, viene attivato un thread di interfaccia utente, diverso da quello del main. In alcuni casi i thread possono procedere in modo indipendente uno dall'altro (comportamento asincrono), in altri devono essere sincronizzati fra loro (es. produttore - consumatore). Si definisce una classe che eredita da Thread e che implementa un metodo run(). Quando si crea un oggetto di questa classe si esegue il suo metodo start() per far partire il thread. class MiaClasse extends Thread { public void run() { System.out.println ("Sono il thread " + getname ());... MiaClasse t1 = new MiaClasse(); MiaClasse t2 = new MiaClasse(); t1.start(); t2.start(); Come si crea un thread Altro modo di creare un thread Per avviare un thread si deve eseguire il metodo start(), che si occupa di inizializzare un nuovo thread e poi chiama run(). Non è possibile chiamare direttamente il metodo run() perché questo non creerebbe un nuovo thread. L ereditarietà è usata in modo poco naturale. Non ha molto senso dire che MiaClasse è un Thread. Quello che si intende è che è possibile attivare un nuovo thread facendogli eseguire il metodo run() della MiaClasse. Si definisce una classe che implementa l'interfaccia Runnable che possiede il metodo run. class Esempio implements Runnable { public void run() {... Per attivare un thread: Esempio es = new Esempio(); Thread t = new Thread(es), t.start();

2 Altro modo di creare un thread Altro modo di creare un thread class MiaClasse implements Runnable { public void run () { System.out.println ("Sono il thread " + Thread.currentThread().getName ());... MiaClasse mt = new MiaClasse(); Thread t1 = new Thread (mt); Thread t2 = new Thread (mt); t1.start(); t2.start(); class MiaClasse implements Runnable { int i = 0; public void run () { i++; System.out.println (i);... MiaClasse mt = new MiaClasse(); Thread t1 = new Thread (mt); Thread t2 = new Thread (mt); t1.start(); t2.start(); Viene stampato prima 1 e poi 2. Infatti esiste un unico oggetto della MiaClasse, legato alla variabile mt, che ha una variabile locale i. I thread t1 e t2 eseguono entrambi il metodo run di questo oggetto, incrementando la stessa variabile i. Sincronizzazione Sincronizzazione di blocchi in Java Il meccanismo di sincronizzazione di Java si basa sulla nozione di monitor. Per ogni classe in Java è possibile definire dei metodi synchronized. I metodi synchronized realizzano delle sezioni critiche. Se una classe contiene dei metodi synchronized, Java associa un lock ad ogni oggetto della classe. Quando un thread chiama un metodo sincronizzato, l'oggetto diventa bloccato (locked). Altri thread che tentano di accedere allo stesso oggetto chiamando metodi sincronizzati rimangono bloccati fino a quando il thread precedente non rilascia l'oggetto, terminando l'esecuzione del metodo. Oltre ai metodi, Java consente di dichiarare synchronized anche blocchi di codice: Object mutexlock = new Object()... public void unmetodo() { sezionenoncritica(); synchronized(mutexlock) { sezionecritica(); sezionenoncritica(); La cosa può essere utile quando solo una piccola parte del codice di un metodo manipola dati condivisi e va quindi eseguita in mutua esclusione.

3 Sincronizzazione I monitor in JAVA Da un metodo sincronizzato si possono chiamare i metodi: wait() - sblocca l'oggetto e mette il thread che lo ha eseguito in una coda di attesa associata all'oggetto; notify() - risveglia un thread a caso fra quelli in attesa, dandogli la possibilità di competere per il lock e di riprendere l'esecuzione dal punto in cui si era messo in wait; notifyall() - risveglia tutti i thread in attesa (ne entra solo uno per volta). Sono metodi di Object e quindi vengono ereditati da qualunque classe. Se si tenta di chiamarli da un metodo non sincronizzato, si ha un errore a runtime. wait ( ) e notify ( ) wait ( ) e notify ( ) Ogni oggetto ha associato un solo wait set (insieme di thread sospesi da un wait() eseguito in un suo metodo di monitor). Con l invocazione di wait(): il monitor viene liberato, lo stato del thread chiamante diventa NOT RUNNABLE. Con l invocazione di notify(), eseguita da un thread (in un metodo di monitor): se il wait set è vuoto, non accade nulla altrimenti, uno (qualsiasi) dei thread nel wait set diventa RUNNABLE.

4 notify ( ) e notifyall ( ) Stati di un thread Un thread reso RUNNABLE tramite notify() deve: riacquisire il possesso del monitor, in competizione (senza particolare priorità) con eventuali altri thread che siano in attesa di entrare nel monitor (avendo invocato un metodo synchronized dello stesso oggetto a monitor già occupato); riverificare subito la condizione attesa (per la quale aveva eseguito wait(); se essa non è verificata, riesegue wait() e si sospende di nuovo (NOT RUNNABLE) nel wait set. Il thread che ha eseguito notify() continua la sua esecuzione. Non è possibile decidere quale thread svegliare mediante notify(): la politica di gestione della coda è diversa da piattaforma a piattaforma. Il metodo notifyall() estrae dal wait set e rende RUNNABLE tutti i thread in attesa. Un thread runnable può essere eseguito. L'effettiva esecuzione dipende dalla politica dello scheduler. Dopo essere stato attivato, un thread può bloccarsi se chiama il metodo sleep esegue una wait (riparte con notify) sta aspettando una operazione di I/O Il thread si ferma quando la run termina. Esistono anche dei metodi suspend, resume e stop, ma sono deprecati. Esempio Realizzazione dei semafori in Java Per evitare che l output si mescoli con quello di altri thread, si può rendere mutuamente esclusivo l uso dell oggetto System.out: synchronized(system.out) { System.out.print( prima parte della ); System.out.println( prima riga, ); System.out.println( seconda riga. ); La cosa funziona purché anche gli altri thread che invocano metodi dello stesso oggetto lo facciano all interno di un blocco protetto con lo stesso statement synchronized. Un semaforo in Java può essere facilmente costruito definendo sem_wait() e sem_signal() come metodi synchronized, cosa che ne assicura l esecuzione in mutua esclusione, ovvero l atomicità. Vediamo, ad esempio, la costruzione di una classe che modelli un semaforo contatore o intero.

5 Esempio Regole di sincronizzazione in Java public class Semaphore() { public Semaphore(int v) { //sem. numerico private int value = v; public synchronized void sem_wait() { while (value <=0) { try { wait(); catch(interruptedexception e){ value--; public synchronized void sem_signal() { ++value; notify(); Un thread che ha ottenuto l accesso a un metodo (o a un blocco) synchronized di un oggetto, può accedere ad altri metodi (o blocchi) synchronized dello stesso oggetto. Un thread può invocare un metodo synchronized di un oggetto dall interno di un metodo synchronized di un altro oggetto (pericoloso: rischio di deadlock). I metodi non synchronized possono essere invocati liberamente, anche se è in corso l esecuzione di un metodo synchronized del medesimo oggetto (però non devono manipolare i dati protetti). Se il wait set di un oggetto è vuoto, l invocazione di notify() o di notifyall() non produce alcun effetto. I thread e la JVM I thread e la JVM: priorità Oltre ai thread creati ed avviati da un applicazione (o da un applet) Java, ce ne sono altri (deamon thread o thread sistema), avviati dalla JVM, per svolgere attività di servizio: thread di gestione della memoria, thread per il controllo grafico, thread di garbage collection, thread di gestione di eventi temporali (sleep(), ). Le specifiche della JVM non indicano come i thread Java debbano essere mappati sulle funzioni multi-tasking del S.O. sottostante: diverse piattaforme possono adottare soluzioni diverse. (In Windows NT, ad es., a ciascun thread Java corrisponde un processo di sistema). A ciascun thread Java è associato un livello di priorità: il livello di priorità minima è Thread.MIN_PRIORITY (1); la priorità massima è Thread.MAX_PRIORITY (10); il livello di default è Thread.NORM_PRIORITY (5); Un thread acquisisce la stessa priorità del thread che lo ha creato; La priorità di un thread può essere impostata in modo esplicito con il metodo setpriority(); La priorità di un thread può essere impostata sia prima che il thread venga avviato con il metodo start(), sia mentre è alive.

6 I thread e la JVM: priorità I thread e la JVM: scheduling Il thread RUNNABLE con la priorità maggiore rimane in esecuzione fino a quando: cede il controllo chiamando il metodo yield; smette di essere eseguibile; un thread di priorità superiore diventa eseguibile. Se ci sono più thread con la stessa priorità, Java non garantisce la politica con cui i thread saranno gestiti. Se si vuole dare la possibilità a tutti i thread di essere attivati, è conveniente far eseguire ogni tanto una sleep ad ogni thread. E' possibile definire gruppi di thread mediante la classe ThreadGroup. In questo modo è possibile gestire tutti i thread del gruppo in modo omogeneo. La JVM gestisce i thread con un meccanismo di scheduling di tipo preemptive a priorità: diviene RUNNING il thread RUNNABLE con priorità più elevata (se ce n è più d uno, viene usata una coda FIFO); lo scheduling da parte della JVM avviene quando: - il thread in esecuzione esce dallo stato RUNNABLE (in seguito a suspend(), stop(), wait(), fine di run(), attesa di I/O); - un thread con priorità più elevata di quello RUNNING diviene RUNNABLE: in questo caso si ha il preemption del thread RUNNING (che diventa RUNNABLE), mentre diviene RUNNING quello a priorità più elevata. I thread e la JVM: time-slicing Problema produttore-consumatore Anche se specifiche della JVM non lo indicano, in alcune piattaforme lo scheduling dei thread può utilizzare anche un meccanismo di timeslicing; in tal caso il thread RUNNING prosegue l esecuzione finché si verifica la prima delle seguenti circostanze: il thread esce dallo stato RUNNABLE; il thread subisce un preemption a favore di un thread con priorità più elevata; è trascorso il quanto temporale assegnato. In assenza di time-slicing un thread può cedere il controllo spontaneamente invocando: yield(): il thread da RUNNING diventa RUNNABLE e consente che divenga RUNNING un altro thread RUNNABLE di uguale priorità; sleep(): il thread diventa NON-RUNNABLE per un po. public class CubbyHole { private int contents ; private boolean available = false; public synchronized int get () { while (available == false) { try { wait(); catch (InterruptedException e) { available = false; notifyall(); return contents; public synchronized void put (int value) { while (available == true) { try { wait(); catch (InterruptedException e) { contents = value ; available = true; notifyall();

7 Problema produttore-consumatore Problema produttore-consumatore public class Producer extends Thread { private CubbyHole cubbyhole ; private int number ; public Producer(CubbyHole c, int number ) { cubbyhole = c; this.number = number; public void run() { for (int i = 0; i < 10; i++) { cubbyhole.put(i); System.out.println("Producer #" + this.number + " put : " + i); try { sleep((int)(math.random() * 100)); catch (InterruptedException e) { public class Consumer extends Thread { private CubbyHole cubbyhole ; private int number ; public Consumer(CubbyHole c, int number ) { cubbyhole = c; this.number = number; public void run() { int value = 0; for (int i = 0; i < 10; i++) { value = cubbyhole.get(); System.out.println("Consumer #" + this.number+ " got : " + value); Problema produttore-consumatore Risorse public class ProducerConsumerTest { public static void main (String [] args) { CubbyHole c = new CubbyHole(); Producer p1 = new Producer (c, 1); Consumer c1 = new Consumer (c, 1); p1.start(); c1.start(); Paul Hyde,"Java Thread Programming, Sams Publishing, Bruce Eckel, Thinking in Java, 3rd Edition, Prentice-Hall, December 2002