Programmazione concorrente in Java. da materiale di Carlo Ghezzi e Alfredo Motta

Транскрипт

1 Programmazione concorrente in Java da materiale di Carlo Ghezzi e Alfredo Motta

2 Parallelismo = multitasking Possiamo scrivere un programma in cui diverse attività (task) evolvono in parallelo da un punto di vista fisico o logico Massimo parallelismo fisico Ogni attività parallela ha a disposizione un processore fisico Altrimenti vengono eseguite da processori condivi Secondo modalità decise da uno scheduler, in generale non controllabile dal programmatore

3 Multitasking su singolo processore Approccio Processore esegue un task Passa velocemente a un altro Sotto il governo dello scheduler Il processore sembra lavorare sui diversi task concorrentemente Passaggio da un task all altro nei momenti di inattività o per esaurimento della finestra temporale ( time sharing )

4 Caso 1: Task singolo Caso 2: Due task 4

5 Multitasking a livello di processi Processo Programma eseguibile caricato in memoria Ha un suo spazio di indirizzi (variabili e strutture dati in memoria) Ogni processo esegue un diverso programma I processi comunicano via SO, file, rete Può contenere più thread

6 Multitasking a livello di thread Thread è un attività logica sequenziale Un thread condivide lo spazio di indirizzi con gli altri thread del processo e comunica via variabili condivise Ha un suo contesto di esecuzione (program counter, variabili locali) Si parla spesso di processo light-weight

7 Thread in Java - metodo 1

8 Classe Thread start join isalive sleep(int ms) yield avvia il thread (eseguendo il metodo run) chiamato su un thread specifico e ha lo scopo di mettere in attesa il thread attualmente in esecuzione fino a quando il thread su cui è stato invocato il metodo join() non termini controlla se il thread è vivo (in esecuzione, in attesa o bloccato) sospende l esecuzione del thread mette temporaneamente in pausa il thread corrente e consente ad altri thread in stato Runnable (qualora ve ne siano) di avere una chance per essere eseguiti

9 public class A extends Thread { public void run() { for (int i=0; i<=5; i++) System.out.println("From Thread A: i= "+i); System.out.println("Exit from A"); public class B extends Thread { public void run() { for (int j=0; j<=5; j++) System.out.println("From Thread B: j= ""+j); System.out.println("Exit from B"); public class C extends Thread { public void run() { for (int k=0; k<=5; k++) System.out.println("From Thread C: k= "+k); System.out.println("Exit from C"); public class ThreadTest { public static void main(string[] args) { new A().start(); new B().start(); new C().start();

10 Output possibili Caso 1 Caso 2 From Thread A: i= 0 From Thread A: i= 1 From Thread A: i= 2 From Thread A: i= 3 From Thread A: i= 4 From Thread A: i= 5 Exit from A From Thread B: j= 0 From Thread B: j= 1 From Thread B: j= 2 From Thread B: j= 3 From Thread B: j= 4 From Thread B: j= 5 Exit from B From Thread C: k= 0 From Thread C: k= 1 From Thread C: k= 2 From Thread C: k= 3 From Thread C: k= 4 From Thread C: k= 5 Exit from C From Thread A: i= 0 From Thread A: i= 1 From Thread A: i= 2 From Thread A: i= 3 From Thread A: i= 4 From Thread A: i= 5 Exit from A From Thread C: k= 0 From Thread C: k= 1 From Thread C: k= 2 From Thread C: k= 3 From Thread C: k= 4 From Thread C: k= 5 From Thread B: j= 0 From Thread B: j= 1 From Thread B: j= 2 From Thread B: j= 3 From Thread B: j= 4 From Thread B: j= 5 Exit from B Exit from C

11 Thread in Java metodo 2 La classe Thread in realtà implementa un interfaccia chiamata Runnable L interfaccia Runnable definisce un solo metodo run che contiene il codice del thread Su ciò si basa un modo alternativo

12 Thread in Java metodo 2 metodo più generale si usa se si deve ereditare da qualche classe

13 Dati condivisi Può essere necessario imporre che certe sequenze di operazioni che accedono a dati condivisi vengano eseguite dai task in mutua esclusione class ContoCorrente { private float saldo; public ContoCorrente(float saldoiniz){ saldo=saldoinizi; public void deposito(float soldi){ saldo += soldi; public void prelievo (float soldi){ saldo -=soldi;...

14 Interferenza Fenomeno causato dall interleaving di operazioni di due o più thread Lettura di y Esecuzione espressione Scrittura in x L esecuzione concorrente di x+=y e x-=y può avere uno dei seguenti effetti incrementare x di y lasciare x immutata decrementare x di y

15 Sequenze atomiche Generalizzazione del problema a volte si vuole che certe sequenze di istruzioni vengano eseguite in isolamento, senza interleaving con istruzioni di altre sequenze parallele che altri thread potrebbero eseguire si parla di sequenze atomiche

16 Altro problema di concorrenza A volte, oltre a voler l atomicità di certe sequenze, si vogliono imporre certi ordinamenti nell esecuzione di operazioni Per esempio, che l operazione A eseguita da un thread venga eseguita prima dell operazione B di un altro thread Di solito ciò deriva dal fatto di voler garantire certe proprietà di consistenza dei dati

17 Come rendere i metodi "atomici" La parola chiave "synchronized applicata a metodi o blocchi di codice class ContoCorrente { private float saldo; public ContoCorrente(float saldoiniz){ saldo = saldoiniz; public synchronized void deposito(float soldi){ saldo += soldi; public synchronized void prelievo(float soldi){ saldo -= soldi;...

18 Esempio public class SynchronizedCounter { private int c = 0; public synchronized void increment() { c++; public synchronized void decrement() { c--; public synchronized int value() { return c;

19 public class TaskA extends Thread { private SynchronizedCounter counter; public TaskA(SynchronizedCounter c) { counter = c; public void run(){ counter.increment(); System.out.println(counter.value()); public class TaskB extends Thread { private SynchronizedCounter counter; public TaskB(SynchronizedCounter c) { counter = c; public void run(){ counter.decrement(); System.out.println(counter.value());

20 public class ThreadTest { public static void main(string[] args) { SynchronizedCounter c = new SynchronizedCounter(); TaskA ta = new TaskA(c); TaskB tb = new TaskB(c); ta.start(); tb.start();

21 Metodi synchronized Java associa un intrinsic lock a ciascun oggetto I lock operano a livello di thread Quando il metodo synchronized viene invocato se nessun metodo synchronized è in esecuzione, l'oggetto viene bloccato (locked) e quindi il metodo viene eseguito se l'oggetto è bloccato, il task chiamante viene sospeso fino a quando il task bloccante libera il lock Al massimo un singolo thread può trovarsi ad eseguire istruzioni all interno di uno stesso metodo synchronized

22 Commenti sul lock Diverse invocazioni di metodi synchronized sullo stesso oggetto non sono soggette a interleaving I costruttori non possono essere synchronized Solo il thread che crea l oggetto deve avere accesso ad esso mentre viene creato Eventuali dati final possono essere letti con metodi non synchronized I dati sono comunque in sola lettura e non possono essere modificati

23 Ulteriori commenti sul lock L intrinsic lock viene acquisito automaticamente all invocazione del metodo synchronized e rilasciato al ritorno (sia normale che eccezionale che da uncaught exception) Se il metodo synchronized fosse static Il thread acquisisce l intrinsic lock per il Class object associato alla classe Pertanto l accesso ai campi static è controllato da un lock speciale, diverso da quelli associati alle istanze della classe

24 Synchronized statements Devono specificare l oggetto a cui applicare il lock public void addname(string name) { synchronized(this) { lastname = name; namecount++; namelist.add(name); Si rilascia il lock all oggetto prima di invocare un metodo che potrebbe a sua volta richiedere di attendere il rilascio di un lock

25 Controllo fine della concorrenza Esempio: classe con due campi che non vengono modificati mai insieme public class TestBlock { private long c1 = 0; private long c2 = 0; private Object lock1 = new Object(); private Object lock2 = new Object(); public void inc1() { synchronized(lock1) {c1++; public void inc2() { synchronized(lock2) {c2++;

26 Alcune regole pratiche Usare lock per la modifica degli attributi dell oggetto Per essere certi di avere uno stato consistente Usare lock per l accesso a campi dell oggetto probabilmente modificati Per evitare di leggere valori vecchi Non usare lock quando si invoca un metodo su altri oggetti Per evitare deadlock Non c è bisogno di lock per accedere alle parti stateless di un metodo

27 Liveness È una proprietà molto importante in pratica Significa che un applicazione concorrente viene eseguita entro accettabili limiti di tempo Le situazioni da evitare attraverso un attenta progettazione sono deadlock, starvation e livelock

28 Deadlock Due o più thread sono bloccati per sempre, in attesa l uno dell altro Esempio: Anna e Giacomo sono amici e credono nel galateo, che dice che se una persona si inchina a un amico, deve restare inchinata fino a che l amico restituisce l inchino Problema: inchino reciproco allo stesso tempo

29 public class Friend { private final String name; public Friend(String name) { this.name = name; public String getname() { return this.name; public synchronized void bow(friend bower) { System.out.format("%s: %s" + " has bowed to me!%n", this.name, bower.getname()); bower.bowback(this); public synchronized void bowback(friend bower) { System.out.format("%s: %s" + " has bowed back to me!%n", this.name, bower.getname());

30 public class ThreadTest { public static void main(string[] args) { final Friend anna = new Friend("Anna"); final Friend giacomo = new Friend("Giacomo"); new Thread(new Runnable() { public void run() { anna.bow(giacomo); ).start(); new Thread(new Runnable() { public void run() { giacomo.bow(anna); ).start(); Classi anonime: approcio comodo per creare nuovi thread con un semplice comportamento

31 Starvation Situazione in cui un thread ha difficoltà ad accedere a una risorsa condivisa e quindi ha difficoltà a procedere Esempio: Task greedy che molto frequentemente invocano metodi lunghi ritardano costantemente il thread Uno scheduler che usa priorità cede sempre precedenza ai task greedy

32 Livelock Errore di progetto che genera una sequenza ciclica di operazioni inutili ai fini dell effettivo avanzamento della computazione Esempio: La sequenza infinita di vada prima lei Diverso dal deadlock: la computazione non è bloccata, qualcosa viene fatto ma mai niente di utile

33 Guarded blocks Come evitare il prelievo se il conto va in rosso? public class ContoCorrente { private float saldo; public synchronized void prelievo (float soldi){ while (saldo-soldi<0) wait(); saldo -= soldi; Rilascia il lock e sospende il thread!

34 Come risvegliare un task in wait? public class ContoCorrente { private float saldo; public ContoCorrente (float saldoi) { saldo = saldoi; synchronized public void deposito (float soldi) { saldo += soldi; notify(); Risveglia un task (scelto a caso) in sospeso da wait su questo oggetto, se esiste public synchronized void prelievo (float soldi) { while (saldo-soldi < 0) wait(); saldo -= soldi; Potrebbe non essere sufficiente... Il thread potrebbe ripartire anche senza essere notificato da nessun altro thread...

35 Esempio: una coda FIFO condivisa Operazione di inserimento di elemento Sospende task se coda piena while (codapiena()) wait(); Al termine notify(); Operazione di estrazione di elemento Sospende task se coda vuota while (codavuota()) wait(); Al termine notify(); Invece, notifyall risveglia tutti i task eventualmente un wait su un determinato oggetto, ma uno solo guadagna il lock!

36 public class FIFO { private boolean empty; private String message; public synchronized String take() { // Wait until message is available. while (empty) { try { wait(); catch (InterruptedException e) { // Toggle status. empty = true; // Notify producer that status has changed. notifyall(); return message; public synchronized void put(string message) { // Wait until message has been retrieved. while (!empty) { try { wait(); catch (InterruptedException e) { // Toggle status. empty = false; // Store message. this.message = message; // Notify consumer that status has changed. notifyall();

37 Ciclo di vita di un thread start born notify notifyall waiting wait ready scheduler running I/O lock dead fine I/O fine lock blocked

38 Problemi con oggetti mutabili public class SynchronizedRGB { // Values must be between 0 and 255 private int red; private int green; private int blue; private String name; private void check(int red, int green,int blue) {// public SynchronizedRGB(int red, int green, int blue, String name) {// public void set(int red, int green, int blue, String name) { check(red, green, blue); synchronized (this) { this.red = red; this.green = green; this.blue = blue; this.name = name; public synchronized int getrgb() {// public synchronized String getname () {// public synchronized void invert () {// Cambia lo stato dell oggetto indipendentemente da gli altri metodi getter..

39 Problema SynchronizedRGB color = new SynchronizedRGB(0,0,0, Pitch Black );... int mycolorint = color.getrgb(); //Statement 1 String mycolorname = color.getname(); //Statement 2 Se un altro thread invoca set dopo Statement 1 ma prima di Statement 2, il valore di mycolorint non corrisponde al valore di mycolorname Il problema sorge perché l oggetto è mutabile

40 Come creare oggetti immutabili Non fornire metodi "setter" Definire tutti gli attributi di istanza final e private Non consentire alle sottoclassi di fare override dei metodi Dichiarando la classe final oppure dichiarando il costruttore private e costruendo gli oggetti mediante factory method Se gli attributi di istanza hanno riferimenti a oggetti mutabili, non consentire la loro modifica Non fornire metodi che modificano oggetti mutabili Non fare sharing di ref a oggetti mutabili Non salvare riferimenti a oggetti esterni mutabili passati al costruttore, se necessario fare copie e salvare riferimenti alle copie Inoltre creare copie degli oggetti interni mutabili se necessario per evitare di restituire gli originali attraverso i metodi

41 Esempio ImmutableRGB Ci sono due metodi setter Il primo (set) trasforma arbitrariamente l oggetto e non avrà alcun corrispettivo nella versione immutabile Il secondo, invert, viene adattato creando un nuovo oggetto invece di modificare l oggetto corrente Tutti gli attributi sono già private; vengono ulteriormente qualificati final La classe viene qualificata final Un solo attributo fa riferimento a un oggetto, e l oggetto è immutabile Non è quindi necessario far nulla per salvaguardare lo stato di eventuali oggetti mutabili contenuti

42 Soluzione ImmutableRGB final public class ImmutableRGB { // Values must be between 0 and 255. final private int red; final private int green; final private int blue; final private String name; private void check(int red, int green, int blue) { if (red < 0 red > 255 green < 0 green > 255 blue < 0 blue > 255) { throw new IllegalArgumentException(); public ImmutableRGB(int red, int green, int blue, String name) { check(red, green, blue); this.red = red; this.green = green; this.blue = blue; this.name = name;

43 Concetti avanzati Finora abbiamo visto i concetti di base, che però risultano inadeguati a un effettiva programmazione concorrente Vediamo ora concetti introdotti in java.util.concurrent.* Oggetti lock Esecutori Collezioni concorrenti Variabili atomiche

44 Oggetti lock - Lock objects Il codice synchronized definisce un caso elementare di lock (implicito), ma meccanismi più sofisticati sono forniti dal package java.util.concurrent.locks Un lock, definito dall interfaccia Lock, può essere acquisito da un solo thread, come nel caso degli implicit lock associati a codice synchronized

45 ReentrantLock A reentrant mutual exclusion Lock with the same basic behavior as the implicit monitor lock accessed using synchronized methods and statements, but with extended capabilities lock() acquires the lock trylock() acquires the lock only if it is not held by another thread at the time of invocation unlock() Attempts to release this lock

46 Classe BowLoop import java.util.random; public class BowLoop implements Runnable { private Friend bower; private Friend bowee; public BowLoop(Friend bower, Friend bowee) { this.bower = bower; this.bowee = bowee; public void run() { Random random = new Random(); for (;;) { try { Thread.sleep(random.nextInt(10)); catch (InterruptedException e) { bowee.bow(bower); Sospende il thread corrente...

47 import java.util.concurrent.locks.lock; import java.util.concurrent.locks.reentrantlock; public class Friend { private final String name; private final Lock lock = new ReentrantLock(); public Friend(String name) { this.name = name; public String getname() { return this.name; public boolean impendingbow(friend bower) { Boolean mylock = false; Boolean yourlock = false; try { mylock = lock.trylock(); yourlock = bower.lock.trylock(); finally { if (! (mylock && yourlock)) { if (mylock) lock.unlock(); if (yourlock) bower.lock.unlock(); return mylock && yourlock; Tenta di acquisire entrambi i lock, torna true se possibile, altrimenti false Ricordatevi di rilasciare i lock che potreste aver parzialmente acquisito

48 public void bow(friend bower){ if (impendingbow(bower)){ try { System.out.format("%s: %s has + " bowed to me!%n", this.name, bower.getname()); bower.bowback(this); finally { Se arriviamo qui lock.unlock(); abbiamo acquisito bower.lock.unlock(); entrambi i lock e dobbiamo else { rilasciarli System.out.format("%s: %s started + " to bow to me, but saw that + " I was already bowing to + " him.%n, this.name, bower.getname()); public void bowback(friend bower) { System.out.format("%s: %s has" + " bowed back to me!%n", this.name, bower.getname());

49 public class ThreadTest { public static void main(string[] args) { final Friend giacomo = new Friend("Giacomo"); final Friend anna = new Friend("Anna"); new Thread(new BowLoop(giacomo, anna)).start(); new Thread(new BowLoop(anna, giacomo)).start(); Tenteranno di inchinarsi in momenti diversi, alcuni riusciranno, altri no quando tentano di farlo allo stesso tempo

50 Esecutori Gli strumenti finora disponibili impongono una stretta relazione tra il compito che deve essere eseguito da un thread (definito dall oggetto Runnable) e il thread stesso, definito dall oggetto Thread I due concetti possono essere tenuti distinti in applicazioni complesse, mediante interfacce Executor thread pools fork/join Gli esecutori sono predefiniti e consentono una gestione efficiente che riduce il pesante overhead dovuto alla gestione dei thread

51 Interfacce Executors Il package java.util.concurrent definisce 3 interfacce Executor ExecutorService (estende Executor) ScheduledExecutorService (estende ExecutorService) Utilizzo di Executor Se r è un Runnable ed e è un Executor, invece di (new Thread(r)).start(); facciamo e.execute(r); evitando l overhead dovuto alla creazione degli oggetti thread

52 Implementazione di Executor Le implementazioni dell interfaccia Executor usano thread pools, ovvero thread (in numero finito) che esistono al di fuori di Runnable Un esempio comune è un executor che usa un fixed thread pool, che viene creato chiamando il factory method newfixedthreadpool() della classe java.util.concurrent.executors Gli oggetti Runnable sono inviati al pool attraverso unacoda Se i thread esistenti sono tutti occupati, tocca aspettare

53 Collezioni concorrenti Il package java.util.concurrent include estensioni a collezioni di Java, quali BlockingQueue Struttura dati FIFO che blocca o dà timeout se si cerca di inserire in coda piena o estrarre da coda vuota ConcurrentMap Consente in maniera atomica di eliminare/modificare una coppia chiave-valore solo se chiave presente e aggiungere chiave-valore solo se assente

54 Variabili atomiche Il package java.util.atomic definisce classi che supportano operazioni atomiche su singole variabili Esse posseggono tutte metodi get e set che si comportano come lettura e scrittura delle corrispondenti variabili non atomiche È disponibile anche un operazione compareandset

55 Oggetti atomici Consentono di evitare i problemi di liveness che possono essere causati dall uso dei metodi synchronized import java.util.concurrent.atomic.atomicinteger; public class AtomicCounter { private AtomicInteger c = new AtomicInteger(0); public void increment() { c.incrementandget(); public void decrement() { c.decrementandget(); public int value() { return c.get();