MultithreadingSi tratta della possibilità di eseguire parti dell’applicazione in parallelo sfruttando le caratteristiche e le potenzialità dei sistemi operativi multithreading.

La classe ThreadAppartiene al package java.lang, quello base che non deve essere importato.Può essere usata per realizzare una temporizzazione dei programmi utilizzando il suo metodo statico sleep(millis):Thread.sleep(2000);Ma anche per realizzare classi che la estendono e che permettono in tal modo dei realizzare un Thread, ovvero un ‘processo’ parallelo.class MiaClasse extends Thread

Overriding di runL’esecuzione di un Thread presuppone l’esistenza di un

operazione di una certa durata caratterizzata solitamente da un ciclo ripetuto diverse volte.

class MiaClasse extends Thread{ public void run() { while(true) {

//…… ciclo infinito } }}Il metodo run non viene mai invocato direttamente, ma per

attivare il thread è necessario usare il metodo start();MiaClasse my=new MiaClasse();my.start();

Thread.sleepCausa la sospensione temporanea del Thread corrente. Il thread ritornerà attivo dopo il numero di millisecondi indicato

try{sleep(1000);}catch(InterruptedException e){}

Il metodo sleep deve essere invocato in un blocco try catch perché lancia l’eccezione InterruptedException.

Ciclo di vita di un Thread

nuovovivo

start

sospeso

Termine dello slot temporale o sleep

wait

Termine dell’attesa

notify

morto

L’interfaccia Runnable Si tratta di un interfaccia creata per permettere di implementare dei

Thread anche a partire da classi che già estendono un’altra classe.class MiaFinestra extends Frame implements Runnable{ public void run() { while(…) { } } public void altroMetodo() { Thread runner=new Thread(this); runner.start(); }}

Priorità dei Thread La maggior parte dei sistemi operativi è in grado di

gestire i Thread con diversi livelli di priorità.Java dispone di 10 livelli di priorità, di questi non tutti sono

realmente differenti nell’utilizzo pratico, perché i sistemi operativi comunemente supportano meno di 10 livelli. Solitamente comunque si usano i tre livelli indicati dalle tre costanti:MIN_PRIORITYNORM_PRIORITYMAX_PRIORITYIl metodo che permette di settare la priorità èsetPriority(n);

Thread ConcorrentiUno dei problemi più rilevanti nello sviluppo di applicazioni

Multithreading è la possibile concorrenza dei thread su dati comuni.Il problema viene risolto generalmente tramite l’utilizzo di

strutture dati per loro natura sincronizzate (Vector, Hashtable) oppure sincronizzando forzatamente tramite la parola chiave synchronized i metodi potenzialmente pericolosi in tal senso.public synchronized void eseguiTransazione(){….} Il metodo sincronizzato verrà richiamato dal metodo run dei

Thread, ma non sarà un methodo del Thread. La sincronizzazione impedisce che il metodo venga interrotto durante la sua esecuzione. In pratica solo un Thread alla volta può usare un metodo sincronizzato. L’oggetto su cui il Thread lavora rimane quindi bloccato finché il metodo sincronizzato non è terminato.

Blocchi sincronizzatiIn alcuni casi non è necessario sincronizzare un intero metodo perché la

parte critica è solo una porzione del codice di un metodo:

La sincronizzazione della porzione critica avviene in questo modo:public void esegui() {

// sezione non critica synchronized (this) {

// sezione critica}// sezione non critica

}

(La parte sincronizzata di un oggetto viene chiamata Monitor, si dice anche che un Thread ha un ‘lock’ sul monitor di un oggetto)

wait e notifyAllL’uso dei metodi wait() e notifyAll() (in un blocco sincronizzato),

appartenenti alla classe Object (non a Thread) permette di sospendere l’esecuzione di un Thread fino al verificarsi di una determinata condizione.

while(conto[da]<importo) wait();conto[da]-=importo;conto[a]+=importo;notifyAll();Dalla situazione di sospensione il Thread tuttavia non si risveglierebbe più

se non venisse invocato il metodo notifyAll(). Questo metodo consente che tutti i Thread rivalutino il loro stato ed eventualmente lascino lo stato di attesa.

L’uso di wait, se mal progettato, potrebbe comunque provocare situazioni di stallo che devono essere ben analizzate: potrebbe cioè accadere che tutti i Thread si portino in stato di attesa senza quindi che nessuno possa più risvegliarli.

(wait() lancia l’eccezione InterruptedException)