Programmazione distribuita - Fondamenti

Programmazione distribuita e thread in Java

Thread e processo

Thread e processo sono concetti fondamentali nella programmazione concorrente. Un processo è un ambiente di esecuzione con uno spazio di memoria privato, e la cooperazione tra processi avviene attraverso InterProcessCommunication come pipe e socket. I thread, invece, esistono all'interno di un processo, condividendo tra loro memoria e file aperti.

Legge di Moore

La legge di Moore afferma che il numero di transistor per chip raddoppia ogni due anni.

Tipi di programmazione concorrente

• Programmazione concorrente eseguita su calcolatori diversi.
• Processi concorrenti sulla stessa macchina (multitasking).
• Processo padre che genera processi figli per fork().

Programmazione concorrente nello stesso processo

I "processi lightweight" all'interno del processo sono i thread. I thread in Java sono oggetti, istanze quindi di una classe Thread. L'evoluzione di Java ha portato a due modalità di gestione dei thread:

1. Istanziare un oggetto Thread ogni volta che serve un task asincrono (creazione e gestione a cura del programmatore).
2. Astrare la gestione, passando un task ad un Executor.

Noi ci focalizziamo sulla prima modalità, di base.

Passi principali per scrivere un thread

1. Estendere la classe java.lang.Thread.
2. Riscrivere (ridefinire, override) il metodo run() nella sottoclasse di Thread.
3. Creare un'istanza di questa classe derivata.
4. Richiamare il metodo start() su questa istanza.

extends Thread(new EsempioThread()).start();
implements Runnable(new Thread(new EsempioThread())).start();

Metodi

• sleep(): cessa temporaneamente l'esecuzione del thread che lo esegue.
• interrupted()
• join(): richiamando join() su un oggetto Thread si blocca il thread corrente fino alla terminazione del thread associato a tale oggetto.
• setPriority()
• currentThread()
• setName()
• interrupt()

wait() e notify() possono essere chiamati solo all'interno di codice sincronizzato. wait() rilascia il blocco sull'oggetto e arresta il thread mettendolo in attesa; notify() sveglia il thread in attesa sullo stesso oggetto.

Errori con la programmazione concorrente

• Interferenza
• Inconsistenza della memoria

Per risolvere questi problemi, è necessaria la sincronizzazione, che a sua volta genera problemi di contesa: quando più thread cercano di accedere alla stessa risorsa simultaneamente (deadlock e livelock).

Sincronizzazione

La happens-before è una garanzia che la memoria scritta da un thread è visibile da un altro thread. La keyword volatile è di solito associata a una variabile il cui valore viene salvato e ricaricato in memoria ad ogni accesso, senza utilizzare i meccanismi di caching e disabilitando alcune ottimizzazioni di riordino delle istruzioni del compilatore.

I metodi sincronizzati (synchronized) sono un costrutto del linguaggio Java, che permette di risolvere semplicemente gli errori di concorrenza, al costo di inefficienza.

Quando un thread esegue un metodo sincronizzato per un oggetto, gli altri thread che invocano metodi sincronizzati dello stesso oggetto sono sospesi fino a quando il primo thread non ha finito.

Sincronizzazione generica

synchronized(this){ ... } // metodo 1
synchronized(this){ ... } // metodo 2

Il metodo 1 e 2 non sono indipendenti.

Sincronizzazione a grana fine

private Object lock1 = new Object();
private Object lock2 = new Object();
synchronized(lock1){ ... } // metodo 1
synchronized(lock2){ ... } // metodo 2

Il metodo 1 e 2 sono indipendenti.

Azioni atomiche

Azioni che non sono interrompibili e si completano (del tutto) oppure per niente. Si possono specificare azioni atomiche in Java per:

• Read e write su variabili di riferimento e su tipi primitivi (a parte long e double).
• Read e write su tutte le variabili volatile.

Write a variabili volatile stabiliscono una relazione happens-before con le letture successive. Tipi di dato definiti in java.util.concurrent.atomic (es: AtomicInteger).

Deadlock e livelock

Un deadlock si verifica quando due thread sono bloccati, ognuno in attesa dell'altro. Un livelock avviene quando un thread A può reagire ad azioni di un altro thread B, che reagisce con una risposta verso A. I due thread non sono bloccati (non è un deadlock!) ma sono occupati a rispondere alle azioni dell'altro. Anche se sono in esecuzione, non c'è progresso!

Speedup e legge di Amdahl

Lo speedup S di un programma X è il rapporto tra il tempo impiegato da un processore per eseguire X rispetto al tempo impiegato da n processori per eseguire X. Sia p la parte del programma X che è possibile parallelizzare: con n processori la parte parallela prende tempo p/n mentre la parte sequenziale prende tempo (1 - p). La legge di Amdahl viene usata per predire l'aumento massimo teorico di velocità che si ottiene usando più processori.

Socket

Java fornisce le API per i socket in java.net. Un indirizzo socket è composto da un indirizzo IP e un numero di porta. I socket su stream sono supportati da due classi:

• ServerSocket: per accettare connessioni (socket di connessione).
• Socket: per scambio di dati (socket di dati).