27/03/2015 Concorrenza multithreading in Java RICHIAMI SU PARALLELISMO 1 Parallelismo = multitasking Possiamo scrivere un programma in cui diverse attività (task) evolvono in parallelo da un punto di vista logico Queste possono evolvere in parallelismo fisico Sistemi multi-processore In passato erano costosi e riservati ad applicazioni speciali Oggi sistemi multiprocessore sono largamente disponibili a livello di massa Massimo parallelismo fisico ogni attività parallela ha a disposizione un processore fisico altrimenti esse vengono eseguite da processori condivisi secondo modalità decise da uno scheduler, in generale non controllabile dal programmatore 3 4 1 27/03/2015 Caso 1: Task singolo 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 di budget temporale ( time sharing ) 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 OS, files, rete Può contenere più thread 7 Caso 2: Due task 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 light-weight process 8 2 27/03/2015 Motivazioni ed esempio La suddivisione in processi e task coglie la struttura logica del problema componenti (processi) che interagiscono ogni componente composto da diversi thread LA SOLUZIONE DI JAVA: THREADS Multiple richieste simultanee da web browser da multipli server, ciascuno multi-threaded 9 Costrutti per la concorrenza a livello di linguaggio C e C++ sono linguaggi «single-threaded» Multitasking in C e C++ richiede di appoggiarsi al sistema operativo, con opportune call alle primitive multithread del SO Java contiene primitive multitasking al suo interno (es. Classe Thread). Es.di thread: il Java garbage collector. Ciò consente di scrivere sw multithread senza occuparsi del SO Alcuni dettagli del multithread in Java sono pero' SOdependent Questo ha consentito sviluppo di librerie di alto livello che semplificano la costruzione di sw multitasking Thread in Java metodo 1 1. Definire una classe che eredita da Thread e contiene il metodo run() class ListSorter extends Thread { public void run() { gli statements del thread che si vuol definire } } 2. Creare istanza della classe ListSorter concSorter = new ListSorter(list1) 3. Invocare il metodo start(), che a sua volta chiama run() lancia il thread e concSorter.start(); ritorna immediatamente12 3 3 27/03/2015 Esempio da Java Tutorial Esempio public class HelloThread extends Thread { @Override public void run() { System.out.println("Hello from a thread!"); } public static void main(String args[]) { (new HelloThread()).start(); } } 13 14 Differenti interleaving Nota 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 15 16 4 27/03/2015 Thread in Java metodo 2 1. Definire una classe che: 1) implementa l'interfaccia Runnable, 2) eventualmente estende altra classe, 3) contiene il metodo run() metodo più class ListSorter implements Runnable { generale si usa se si deve public void run() { gli statements del thread che si vuol definireereditare da } qualche } classe 2. Creare istanza Esempio public class HelloRunnable implements Runnable { public void run() { System.out.println("Hello from a thread!"); } ListSorter concSorter = new ListSorter(list1); public static void main(String args[]) { (new Thread(new HelloRunnable())).start(); } 3. Creare thread Thread myThread = new Thread(concSorter); 4. Attivare metodo run, attraverso metodo start() myThread.start() 17 Ciclo di vita di un thread (semplificato) born La classe Thread prevede anche metodi e caratteristiche che consentono un controllo molto (a volte troppo!) fine della concorrenza, spesso dipendente dal SO e che qui IGNORIAMO, p.es.: start ready scheduler lock 18 Dettagli vari costruito running I/O } sleep(x) sospende il thread per x msec (stato sleeping) interrupt(): inviare interrupt al thread (ad. es. per terminarlo); il suo run() di norma lancia InterruptedException; fine I/O fine lock Ogni thread ha priorità (compresa fra Thread.Min_Priority e Thread.Max_Priority, di default Thread.Norm_Priority) blocked dead 19 La priorità è usata dallo scheduler per decidere quali thread sono running 5 27/03/2015 Dati condivisi Esempio di run 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 = saldoIniz; } public void deposito (float soldi) { saldo += soldi; } public void prelievo (float soldi) { saldo -= soldi; } che succede se due task concorrenti cercano l'uno di depositare e l'altro di prelevare dallo stesso conto? 1. All'inizio saldo = 100 2. Un Thread1 chiama deposito(50), inizia esecuzione, calcola il valore di saldo+soldi=150 ma non fa in tempo a scriverlo in saldo 3. prelievo ed esegue completamente saldo -= soldi: ora saldo=50. 4. Thread1 continua e esegue saldo=150. 5. Abbiamo prelevato 50 e depositato 50 ma il nostro saldo è aumentato! public void deposito (float soldi){ saldo += soldi; } public void prelievo (float soldi) { saldo -= soldi; } 21 Es: Interferenza Soluzione: Sequenze atomiche Esecuzione concorrente di x+=y e x-=y. Ciascun thread esegue tre operazioni: 1.Lettura del valore di x e y 2.Calcolo di espressione (x+y oppure x-y) 3.Scrittura in variabile 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 22 23 Generalizzazione del problema a volte si vuole che certe sequenze di istruzioni/interi metodi vengano eseguite in isolamento, senza interleaving con istruzioni di altre sequenze parallele che altri thread potrebbero eseguire si parla di sequenze atomiche In java quasi nessuna istruzione è atomica (p.es. anche x++ è in realtà una sequenza di istruzioni) 24 6 27/03/2015 Imporre ordinamenti Come rendere i metodi "atomici" A volte, oltre a voler l'atomicità di certe sequenze, si vogliono imporre certi ordinamenti nell'esecuzione di operazioni Per esempio, l'operazione A eseguita da un thread deve essere eseguita prima (happens before) dell'operazione B di un altro thread Di solito ciò deriva dal fatto di voler garantire certe proprietà di consistenza della memoria (stato della computazione) La parola chiave "synchronized" class ContoCorrente { private float saldo; public ContoCorrente (float saldoIniz) { saldo = saldoIniz; } synchronized public void deposito (float soldi) { saldo += soldi; } synchronized public void prelievo (float soldi) { saldo -= soldi; } 25 Esempio: contatore sincronizzato public class SynchronizedCounter { private int c = 0; 26 Metodi synchronized Java associa un intrinsic lock (monitor) a ciascun oggetto che ha almeno un metodo synchronized public synchronized void increment() { c++; } Ogni estensione di object può avere metodi synchronized Quando un metodo synchronized è invocato: public synchronized void decrement() { c--; } public synchronized int value() { return c; } } se l'oggetto non è bloccato (ossia nessun metodo synchronized è in esecuzione sull'oggetto), l'oggetto viene bloccato (locked) e quindi il metodo è eseguito se l'oggetto è bloccato, il task chiamante viene sospeso fino a quando il task bloccante libera il lock 27 NB: un metodo non synchronized non è mai 28 bloccato. 7 27/03/2015 Commenti su intrinsic lock Diverse invocazioni di metodi synchronized sullo stesso oggetto non sono soggette a interleaving quanto un thread X esegue un metodo synchronized di un oggetto, i thread che eseguono invocazioni di metodi synchronized sullo stesso oggetto vengono sospesi fino a che X termina l'esecuzione del metodo Quando un metodo synchronized termina, stabilisce automaticamente una relazione happens-before con ogni invocazione successiva di metodi synchronized sullo stesso oggetto NOTA eventuali dati final (che non possono essere modificati dopo la creazione) possono essere letti con metodi non synchronized Ulteriori commenti sul lock L'intrinsic lock viene acquisito automaticamente all'invocazione di un metodo synchronized e rilasciato al ritorno (normale o eccezionale o da uncaught exception) NB: Caso di invocazione di metodo static synchronized: 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 29 30 Costruttori non synchronized I costruttori non possono essere synchronized. Motivo: Solo il thread che crea l'oggetto può avere accesso ad esso mentre viene creato, in quanto l'oggetto non viene normalmente mostrato prima che la sua costruzione e l'inizializzazione siano completate. Non vi è quindi ragione di rendere il costruttore synchronized. Gli altri threads non possono vedere l'oggetto creato fino a che la costruzione non è completa, a meno non il costruttore non «faccia uscire» un riferimento all'oggetto durante la costruzione per esempio generare una lista instances di oggetti creati mediante l'istruzione instances.add(this), contenuta nel costruttore (che rende visibile l'oggetto o sue parti prima che la costruzione sia completata. Questo modo di procedere è comunque da evitare Se proprio necessario ci sono modi per «bloccare» le parti del costruttore che restituiscono l'ogetto Come evitare deadlock, starvation e livelock LIVENESS 8 27/03/2015 Deadlock Liveness Un'applicazione concorrente deve essere eseguita entro accettabili limiti di tempo E' una proprietà molto importante in pratica Può essere violata per «colpa» dei metodi synchronized Principali situazioni da evitare attraverso un'attenta progettazione deadlock, starvation e livelock Un modo per evitare queste situazioni è ridurre l'uso di metodi synchronized, introducendo dei lock «piu' fini» a livello di singole istruzioni Due e più thread sono bloccati per sempre, in attesa l'uno dell'altro Esempio: Al e Joe 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 33 34 http://docs.oracle.com/javase/tutorial/essential/concurrency/deadlock.html 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); //ASPETTA RESTITUZIONE INCHINO } public synchronized void bowBack(Friend bower) { System.out.format("%s: %s" + " has bowed back to me!%n", this.name, bower.getName()); } } final Friend al= new Friend("Al"); final Friend joe= new Friend("Joe"); new Thread(new Runnable() {public void run() {al.bow(joe);}}).start(); 35 new Thread(new Runnable() {public void run() {joe.bow(al);}}).start(); Starvation Situazione in cui un thread ha difficoltà a guadagnare accesso a una risorsa condivisa e quindi ha difficoltà a procedere Esempi: altri task ingordi ( greedy ) che molto frequentemente invocano metodi lunghi ritardano costantemente il thread, uno scheduler che usa priorità cede sempre precedenza a task greedy che hanno alta priorità Caso più raro del deadlock, ma può 36 9 27/03/2015 Synchronized statements 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 E' un caso abbastanza raro, ma possibile. 37 Synchronized statements su oggetti diversi da this Es. classe XXX ha 2 campi c1 e c2, mai usati assieme. I loro update devono essere synchronized, ma non c'e motivo di impedire di farne interleaving: si ridurrebbe la concorrenza con blocchi non necessari public class XXX { private long c1 = 0; private long c2 = 0; final private Object lock1 = new Object(); final private Object lock2 = new Object(); public void inc1() { synchronized(lock1) { c1++; } } public void inc2() { synchronized(lock2) { c2++; } 39 } invece di usare synchronized methods o sync. Statement su this, si creano due oggetti al solo scopo di fornire un lock lock1 usato per bloccare c1, lock per c2. Quindi ogni volta che si deve usare c1 occorre bloccare lock1. Utili per ridurre problemi di liveness dovuti a synchronized methods Devono specificare un oggetto a cui applicare il lock, qui this public void addName(String name) { synchronized(this) { lastName = name; nameCount++; } nameList.add(name); } in questo modo si rilascia il lock sull'oggetto this prima di invocare metodo nameList.add, che potrebbe a sua volta richiedere di attendere il rilascio di un lock (potenziali 38 problemi di liveness, come nel caso dell'inchino) Synchronized statements: controllo fine della concorrenza Vantaggio: diminuiscono le parti di codice che devono essere synchronized Minore possibilità di deadlock Codice più efficiente Utile in pratica, ma richiede MOLTA attenzione: controllo così fine spesso induce errori di programmazione, o comunque risulta molto complesso Nell'es., siamo proprio sicuri che possiamo lasciare interleaving degli update di c1 e c2? Se usiamo c1 e ci dimentichiamo di fare il lock? Vedremo alternative più avanti 40 } 10 27/03/2015 Precondizioni per metodi synchronized: guarded blocks Come evitare il prelievo se il conto va "in rosso"? class ContoCorrente { private float saldo; WAIT E NOTIFY synchronized public void prelievo (float soldi) { while (saldo-soldi<0) wait(); saldo -= soldi; } rilascia il lock sull'oggetto e sospende il 42 task («va in wait») Come risvegliare un task in wait? class ContoCorrente { private float saldo; public ContoCorrente (float saldoIniz) { saldo = saldoIniz; } synchronized public void deposito (float soldi) { saldo += soldi; risveglia un task sospeso notify(); in wait, se esiste nondeterminismo } synchronized public void prelievo (float soldi) { while (saldo-soldi<0) wait(); saldo -= soldi; } Attenzione! if (saldo-soldi<0) wait(); Non è sufficiente: il saldo potrebbe non 43 essere diventato positivo Ciclo di vita «completo» di un thread born start notify notifyAll ready scheduler wait running I/O lock waiting fine I/O fine lock blocked dead 44 11 27/03/2015 Attenzione ai dettagli Ancora dettagli Un thread che e' andato in wait puo' essere risvegliato solo da un notify o notifyAll Chiamando wait() occorre in realtà anche catturare l'eccezione checked InterruptedException (lanciata se un altro thread invoca metodo interrupt() sul thread in sospeso, ad es. perche' esecuzione del programma viene abortita) La soluzione più semplice (ma non sempre la migliore) è aggiungere clausola throws InterruptedException al metodo che chiama la wait. Esempio: synchronized public void prelievo (float soldi) throws InterruptedException { while (saldo-soldi<0) wait(); saldo -= soldi; } altrimenti resta in wait per sempre E' un caso diverso dal thread che si è bloccato perche' chiama un metodo synchronized su un oggetto locked Questo infatti procederà quando l'oggetto sara' unlocked, senza bisogno di notify. Quando risvegliato, il thread «compete» con altri thread in attesa ma che non erano in wait Esempio: una coda fifo condivisa Schema produttore/consumatore con buffer unitario 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 in sospeso MA uno solo guadagna il lock 47 public synchronized void put(String message) { public synchronized String take() { // Wait until message has // Wait until message is // been retrieved. // available. while (!empty) { while (empty) { try { try { wait(); wait(); } catch (InterruptedException e) {} } catch (InterruptedException e) {} } } // Toggle status. // Toggle status. empty = false; empty = true; // Store message. this.message = message; // Notify producer that // Notify consumer that status // status has changed. // has changed. notifyAll(); notifyAll(); return message; 48 } } 12 27/03/2015 Differenza notify - notifyAll Nel dubbio, usare notifyAll (che però e' meno efficiente perche' risveglia TUTTI i thread in wait) Notify risveglia un solo thread. Utile quando sappiamo che ce n'e' uno solo in attesa o se non importa quale deve procedere. Es: il prod/cons con un solo thread producer e un solo thread consumer: basta notify Se pero' molti prod e molti cons con notify si può avere deadlock: necessario notifyAll deadlock perche' ci possono essere threads non in wait che bloccano il buffer e impediscono al thread in wait di proseguire Synchronized in sola lettura? Per consentire ottimizzazioni e caching di parte della JVM, accesso concorrente anche in sola lettura richiede un lock JVM può memorizzare in una cache locale al singolo thread il valore di ogni variabile (es. threads che stanno su core diversi) JVM (per motivi di ottimizzazione, a seconda dell architettura dello HW) può riordinare, anticipare o ritardare l esecuzione di alcune istruzioni, fra cui l update di una variabile: Deadlock producer/consumer con notify 3 threads P1,P2,P3 produttori; C1,C2 C3 consumatori, un Buffer b. (leggono/scrivono sullo stesso Buffer) P1: b.put(..), che scrive ed esce. P2: b.put(..) e va in wait (b pieno) P3: b.put(..) e va in wait (b pieno) C1: b.take(), che comincia l'esecuzione. Ora b è locked C2, C3: b.take(): b e' locked, quindi si bloccano C1 finisce di eseguire b.take(..), che chiama notify ed esce La notify risveglia P2, ma C2 entra prima di P2 e fa lock di b: P2 si blocca (NON in wait) 8. Ma C2 va in wait perche' b vuoto 9. C3 si sblocca ed esegue b.take(), ma b vuoto: wait 1. 2. 3. 4. 5. 6. 7. ORA P3, C2, e C3 SONO IN WAIT 10.P2 acquisisce lock, esegue b.put(..) che fa notify ed esce. 11.Il notify risveglia P3, che pero' va in wait perche' buffer non vuoto 12.DEADLOCK: 3 thread in wait, e nessun altro thread che faccia notify! volatile (cenni) Alternativa a sincronizzazione in lettura: dichiarare la variabile «volatile» private volatile int x; Utile SOLO quando ci sono alcuni threads che leggono soltanto, ma che non scrivono mai. P. es. un costruttore di solito ritorna il reference prima di avere inizializzato l oggetto! Allora la lettura non sincronizzata di una variabile può essere del tutto errata. Un thread non sincronizzato: continua a usare il valore nella cache locale, senza mai accorgersi che altri thread hanno modificato il valore della variabile. Perde gli update di un altro thread in esecuzione che sono stati ritardati. Un thread synchronized quando prende/rilascia il lock forza tutti gli update, sincronizzando anche la propria cache con la memoria principale. La lettura o scrittura di x non può essere riordinata dalla JVM Tutte le istruzioni che seguono nel thread il read/write di x sono eseguite dopo il read/write, tutte quelle che precedono sono eseguite prima. La lettura di x è atomica e avviene dalla memoria principale La scrittura della variabile forzala sincronizzazione della cache locale del thread con la memoria principale Si perdono ottimizzazioni del compilatore, con diminuzione di efficienza 13 27/03/2015 Problemi con oggetti mutabili D a http://docs.oracle.com/jav ase/tutorial/essential/concurrency/syncrgb.html 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) { if (red < 0 || red > 255 || green < 0 || green > 255 || blue < 0 || blue > 255) { throw new IllegalArgumentException(); } } 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; } } Possibile inconsistenza 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 color.set dopo Statement 1 ma prima di Statement 2, il valore di myColorInt non corrisponde al valore di myColorName. Fix: legare assieme i due statement in un unico synchronized statement public synchronized int getRGB() { //calcola intero che rappresenta il colore con manipolazione // rappresentazioni binarie: bitwise inclusive or | e shift sx << ||es. 4|1 dà 5, << X esegue shift a sinistra di X posizioni return ((red << 16) | (green << 8) | blue); } public synchronized String getName(){ return name; } public SynchronizedRGB(int red, int green, int blue, String name) { check(red, green, blue); this.red = red; this.green = green; this.blue = blue; this.name = name; } public synchronized void invert() { red = 255 - red; green = 255 - green; blue = 255 - blue; name = "Inverse of " + name; 53 } } Oggetti immutabili Oggetti immutabili: sono quelli che non possono cambiare stato Non sono quindi soggetti a interferenza ne' osservabili in uno stato inconsistente Programmatori spesso riluttanti a usarli perché poco efficienti , MA: il costo di creazione di nuovi oggetti al posto della loro modifica è spesso sovrastimato (e alto per collezioni, ma basso per oggetti semplici come RGB dell esempio). overhead dovuto a garbage collection si riduce si elimina codice necessario a proteggere oggetti mutabili da modifiche non volute e da multithreading. Maximum reliance on immutable objects is widely accepted as a sound strategy for creating simple, reliable code . synchronized (color) { int myColorInt = color.getRGB(); String myColorName = color.getName(); } Quindi oltre ad avere dichiarato synchronized vari metodi e statement di SynchronizedRGB, dobbiamo aggiungere ulteriori sync. nel codice che usa la classe! Ma abbiamo già visto che molty sync. Stat. e meth. possono dare problemi Il problema può sorgere solo perché l'oggetto è mutabile:54si può definire un SynchronizedRGB immutabile Come creare oggetti immutabili Non fornire metodi "setter" Definire tutti gli attributi di istanza final e private Se gli attributi di istanza hanno riferimenti a oggetti mutabili, non consentire la modifica di questi ultimi: - Non fornire metodi che modificano oggetti mutabili - Non fare sharing di ref. a oggetti mutabili. Non salvare ref. a oggetti esterni mutabili passati al costruttore, se necessario fare copie e salvare ref. alle copie. Inoltre creare copie degli oggetti interni mutabili se necessario per evitare di restituire gli originali attraverso i metodi - per garantire imutabilità può essere necessario anche non consentire alle sottoclassi di fare override dei metodi (p.es. dichiarando la classe final), dichiarare il costruttore private e 56 costruendo gli oggetti mediante metodi statici, detti factory methods 14 27/03/2015 Soluzione ImmutableRGB Esempio ImmutableRGB final public class ImmutableRGB { Nella versione mutabile 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 57 Concetti avanzati: java.util.concurrent Finora abbiamo visto i concetti di base, che però risultano inadeguati a un'effettiva programmazione concorrente Sono «di basso livello» e richiedono al programmatore di scendere troppo nei dettagli, rendendo i programmi difficile da scrivere e mantenere. Vediamo ora concetti introdotti con Java 5.0, in particolare nei packages java.util.concurrent Oggetti lock Esecutori Collezioni concorrenti Variabili atomiche Il suggerimento è di usare questi strumenti al posto di wait e notify non appena possibile 59 // 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; } Oggetti lock public int getRGB() { return ((red << 16) | (green << 8) | blue); } public String getName() { return name; } public ImmutableRGB invert() { return new ImmutableRGB(255 - red, 255 - green, 255 - blue, "Inverse of " + name); } } 58 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 E' pero possibile ritirarsi dalla richiesta di lock il metodo trylock esce dal lock se questo non è disponibile (immediatamente o dopo un timeout da specificare) il metodo lockInterruptibly consente il ritiro se un altro thread manda un interrupt prima che il lock sia acquisito 60 15 27/03/2015 Friend: bow e bowBack Esempio: Al, Joe e l'inchino class Friend { 1: Creazione dei thread oggetti Friend devono acquisire i locks di entrambi i partecipanti prima di proseguire con l'inchino. public static void main(String[] args) { final Friend joe= new Friend("Joe"); final Friend al= new Friend("Al"); new Thread(new BowLoop(joe, al)).start(); new Thread(new BowLoop(al, joe)).start(); } BowLoop e' una classe di prova che fa inchinare per sempre Al e Joe ad intervalli d tempo casuali 61 Friend: l'attributo lock e il metodo impendingBow class Friend { private final Lock lock = new ReentrantLock(); //attributo per fare lock public boolean impendingBow(Friend bower) { Boolean myLock = false; Boolean yourLock = false; try { myLock = lock.tryLock(); //cerca di bloccare this.lock yourLock = bower.lock.tryLock(); //cerca di bloccare bower.lock } finally { if (! (myLock && yourLock)) {//se non ha entrambi i lock, rilascia if (myLock) { lock.unlock(); } if (yourLock) { bower.lock.unlock(); } } } 63 return myLock && yourLock; } } restituisce vero se riesce ad acquisire il lock di ciascuno dei due attori che consentono all'uno di inchinarsi e all'altro di restituire l'inchino 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 {//in uscita si rilasciano i lock di this e del bower: lock.unlock(); bower.lock.unlock(); } } else { 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()); } 62 import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; import java.util.Random; public class Safelock { static 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; } Codice completo PARTE 1 64 16 27/03/2015 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 { lock.unlock(); bower.lock.unlock(); } } else { System.out.format("%s: %s started" + " to bow to me, but saw that" + " I was already bowing to" + " him.%n", this.name, bower.getName()); } } static 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); } } Codice completo PARTE 2 Codice completo PARTE 3 } public void bowBack(Friend bower) { System.out.format("%s: %s has" + " bowed back to me!%n", this.name, bower.getName()); } public static void main(String[] args) { final Friend al = new Friend("Al"); final Friend joe = new Friend(«Joe"); new Thread(new BowLoop(al, joe)).start(); new Thread(new BowLoop(joe, al)).start(); } } 65 } 66 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 Implementazione con thread pools Implementazione con fork/join Gli esecutori sono predefiniti e consentono una gestione efficiente che riduce il pesanti overhead dovuto alla gestione dei thread67 Thread Pools Utili per limitare il numero di thread in esecuzione allo stesso tempo. sovraccarico delle prestazioni associato ad inizializzare un nuovo thread, assegnargli memoria memoria per lo stack ecc Un server che riceve continuamente richieste potrebbe bloccarsi completamente Invece di avviare un nuovo thread per ogni task, una task è passata a un thread pool. Non appena il thread pool ha qualche thread inattivo, il task gli viene assegnato ed eseguito. Uso tipico per i server: ogni connessione in entrata è passata al pool. 17 27/03/2015 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 69 Cenno al Fork/Join framework E' un'altra implementazione di ExecutorService, utile nel caso di più processori Consente di distribuire task a elementi di un thread pool secondo uno schema ricorsivo: if (il mio task è abbastanza piccolo) eseguo direttamente else spezzo il mio task in due task invoco i due pezzi e attendo il risultato Implementazione di Executors Le implementazioni dell'interfaccia Executors usano thread pools, che consistono di thread che esistono al di fuori di Runnable Un esempio comune è l'implementazione di Executor che usa un fixed thread pool , che viene creato chiamando il factory method newFixedThreadPool della classe java.util.concurrent.Executors I task sono inviati al pool attraverso una coda (BlockingQueue) 70 Collezione concorrenti Molte collezioni «standard» di Java non sono synchronized, per motivi di efficienza Se serve usare collezioni in ambito multithread, occorrebbe 1) Definire le proprie collez. synchronized, oppure 2) Usare le collezioni synchronized previste dal package java.util.collections. Ora nuove collezioni in java.util.concurrent Es. ArrayList NON è synchronized: non adatto a multithread ing. Si può definire una versione sincronizzata così: List m = Collections.synchronizedList(new ArrayList()); 71 18 27/03/2015 java.util.concurrent Variabili atomiche BlockingQueue struttura dati FIFO che blocca thread se si cerca di inserire in coda piena o estrarre da coda vuota Utile come buffer per produttore/consumatore ConcurrentHashMap (implementa ConcurrentMap) Rende atomiche le operazioni di 1) eliminazione/modifica di una coppia chiave-valore solo se chiave presente e 2) aggiunta chiave-valore solo se assente Molto efficiente perche 1) evita di sincronizzare l intera hash map, ma solo la porzione che serve e 2) la lettura dei dati avviene senza lock. 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 E' disponibile anche un'operazione compareAndSet 73 Esempio class Counter { private int c = 0; class SynchronizedCounter { private int c = 0; public synchronized void increment() { c++; public void increment() { c++; } } public void decrement() { c--; } public synchronized void decrement() { c--; } public int value() { return c; } public synchronized int value() { return c; } } } PROBLEMI DI INTERFERENZA! NO INTERFERENZA MA POTENZIALI DEADLOCK! Alternativa dei synchronized statement è soluzione molto «fine» che 75 porta facilmente a errori. Cosa fare? 74 Esempio con Oggetti atomici import java.util.concurrent.atomic.AtomicInteger; class AtomicCounter { private AtomicInteger c = new AtomicInteger(0); public void increment() { c.incrementAndGet(); } public void decrement() { c.decrementAndGet(); } public int value() { return c.get(); } Consentono di evitare i problemi di liveness che possono essere causati dall'uso dei metodi synchronized, senza le 76 complicazioni dei syncronized statements 19 27/03/2015 Array Atomici Java 5 fornisce anche implementazioni atomiche di array: AtomicIntegerArray, AtomicLongArray and AtomicReferenceArray Metodi per accesso atomico a un elemento dell array: compareAndSet(int indice), incrementAndGet(int indice) Programmazione distribuita 78 Obiettivo Nodi fisici e nodi logici La rete come architettura fisica programmabile Poter allocare computazioni su nodi fisici diversi e consentire il coordinamento tra le computazioni sui diversi nodi 79 Occorre distinguere tra nodi fisici e logici Può essere opportuno progettare ignorando all'inizio il nodo fisico in cui un nodo logico sara' allocato Java consente di addirittura di vedere tutto attraverso la nozione di oggetti e di invocazione di metodi, dove l'invocazione può essere remota 80 20 27/03/2015 Architettura client-server Middleware È il modo classico di progettare applicazioni distribuite su rete Server offre un servizio "centralizzato" attende che altri (client) li contattino per ottenere un servizio esempio: web server Client si rivolge ad apposito/i server per ottenere certi servizi esempio: browser www 81 Per programmare un sistema distribuito vengono forniti servizi specifici, come estensione del sistema operativo Il middleware viene posto tra il sistema operativo e le applicazioni In Java il middleware fa parte del linguaggio, diversamente da altri middleware (es. CORBA) 14 82 15 Socket in Java Middleware package java.net, classi: Socket, ServerSocket Client e server comunicano (pacchetti TCP) attraverso socket (attacchi) socket client 83 socket server Endpoint individuati da: indirizzo IP numero di porta (uno per ogni applicazione) 84 21 27/03/2015 Comunicazione client-server Socket come stream Apertura, lettura e scrittura di socket del tutto simili a gestione IO con stream Differenza: Metodo accept per mettersi in ascolto Metodo connect per iniziare una connessione 1 2 Un oggetto di tipo Socket e' associato a uno stream di input, da cui leggere, e uno stream di output su cui scrivere 3 1. il ServerSocket del server si mette in attesa di una connessione 2. il socket del client si collega al server socket 3. viene creato un socket nel server e quindi stabilito un canale di comunicazione con i l client Metodi getInputStream e getOutputStream. E' possibile stabilire connessioni TCP o UDP. 85 Attesa connessione (lato server) 1. Creare un'istanza della classe java.net.ServerSocket specificando il numero di porta su cui rimanere in ascolto ServerSocket serverSocket=new ServerSocket(4567); 2. Chiamare il metodo accept() che fa in modo che il server rimanga in ascolto di una richiesta di connessione (la porta non deve essere già in uso) Socket mioSocket=serverSocket.accept(); 3. Quando il metodo completa la sua esecuzione la connessione col client è stabilita e viene restituita un'istanza di java.net.Socket connessa al client remoto 87 Attenzione a UDP che non ha gestione degli errori (puo' Aprire connessione (lato client) 1. Aprire un socket specificando indirizzo IP e numero di porta del server Socket socket = new Socket("127.0.0.1", 4567) 2. All'indirizzo e numero di porta specificati ci deve essere in ascolto un processo server Socket socket=serverSocket.accept(); 3. Se la connessione ha successo si usano (sia dal lato client che dal lato server) gli stream associati al socket per permettere la comunicazione tra client e server (e viceversa) Scanner in = new Scanner(socket.getInputStream()); PrintWriter out = new PrintWriter(socket.getOutputStream()); 88 22 27/03/2015 Esempio di server: EchoServer Si crei un server che accetta connessioni TCP sulla porta 1337 Una volta accettata la connessione il server leggerà ciò che viene scritto una riga alla volta e ripeterà nella stessa connessione ciò che è stato scritto. Se il server riceve una riga quit chiuderà la connessione e terminerà l' 89 esecuzione Esempio di client: LineClient Si crei un client che si colleghi, con protocollo TCP, alla porta 1337 dell'indirizzo IP 127.0.0.1 Una volta stabilita la connessione il client legge una riga alla volta dallo standard input e invia il testo digitato al server Il client inoltre stampa sullo standard output le risposte ottenute dal server Il client deve terminare quando il server 91 chiude la connessione public class EchoServer { private int port; public void startServer() throws IOException { serverSocket = new ServerSocket(port); // apro una porta TCP System.out.println("Server socket ready on port: " + port); Socket socket = serverSocket.accept(); // resto in attesa di una connessione System.out.println("Received client connection"); // apro gli stream di input e output per leggere e scrivere nella connessione appena ricevuta: Scanner in = new Scanner(socket.getInputStream()); PrintWriter out = new PrintWriter(socket.getOutputStream()); while (true) {// leggo e scrivo nella connessione finche' non ricevo "quit": String line = in.nextLine(); if (line.equals("quit")) { break; } else { out.println("Received: " + line); out.flush(); } } System.out.println("Closing sockets"); // chiudo gli stream e il socket in.close(); out.close(); socket.close(); serverSocket.close(); } 90 public class LineClient { private String ip; private int port; public void startClient() throws IOException { Socket socket = new Socket(ip, port); System.out.println("Connection established"); Scanner socketIn = new Scanner(socket.getInputStream()); PrintWriter socketOut = new PrintWriter(socket.getOutputStream()); Scanner stdin = new Scanner(System.in); try { while (true) { String inputLine = stdin.nextLine(); socketOut.println(inputLine); socketOut.flush(); String socketLine = socketIn.nextLine(); System.out.println(socketLine); } } catch(NoSuchElementException e) { System.out.println("Connection closed"); } finally { stdin.close(); socketIn.close(); socketOut.close(); socket.close(); } } 92 23 27/03/2015 Creare EchoServer e LineClient public class EchoServer { private int port; private ServerSocket serverSocket; public EchoServer(int port) { this.port = port; } public static void main(String[] args) { EchoServer server = new EchoServer(1337); try { server.startServer(); } catch (IOException e) { System.err.println(e.getMessage()); } } } public class LineClient { private String ip; private int port; public void startClient() throws IOException { public LineClient(String ip, int port) { this.ip = ip; this.port = port; } public static void main(String[] args) { LineClient client = new LineClient("127.0.0.1", 1337); try { client.startClient(); } catch (IOException e) { System.err.println(e.getMessage()); } } } Serializzazione E se devo inviare oggetti? Posso inviare tramite socket anche un oggetto a patto che sia «serializzabile». Serializzazione=trasformazione di un oggetto in un byte stream Classe dell'oggetto deve implementare l'interfaccia Serializable 93 Es. serializzazione ClasseSerializzabile o = new ClasseSerializzabile (); //Decorazione flusso uscita del socket ObjectOutputStream objOut = new ObjectOutputStream(socket.getOutputStream()); //Scrittura dell'oggetto o sul socket socket: objOut.writeObject(o); //Decorazione flusso uscita del socket: ObjectInputStream in = new ObjectInputStream(socket.getInputStream()); //Lettura di un oggetto dal socket: o = (ClasseSerializzabile)objInputStream.readObject(); Architettura del server Il server che abbiamo visto accetta una sola connessione (da un solo client) Un server dovrebbe essere in grado di accettare connessioni da diversi client e di dialogare con questi contemporaneamente Idea: server multi-thread All'interno del processo Server far eseguire l'istruzione accept() in un nuovo thread In questo modo è possibile accettare più client contemporaneamente 96 24 27/03/2015 Esempio: EchoServer multithread Spostiamo la logica che gestisce la comunicazione con il client in una nuova classe ClientHandler che implementa Runnable La classe principale del server si occupa solo di istanziare il ServerSocket, eseguire la accept() e di creare i thread necessari per gestire le connessioni accettate La classe ClientHandler si occupa di gestire la comunicazione con il client associato al socket assegnato 97 EchoServer multi-thread (Client handler) public class EchoServerClientHandler implements Runnable { private Socket socket; public EchoServerClientHandler(Socket socket) { this.socket = socket; } public void run() { try { Scanner in = new Scanner(socket.getInputStream()); PrintWriter out = new PrintWriter(socket.getOutputStream()); // leggo e scrivo nella connessione finche' non ricevo "quit" while (true) { String line = in.nextLine(); if (line.equals("quit")) { break; } else { out.println("Received: " + line); out.flush(); } } // chiudo gli stream e il socket in.close(); out.close(); socket.close(); } catch (IOException e) { System.err.println(e.getMessage()); } } } 98 EchoServer multi-thread (Server) public class MultiEchoServer { private int port; public MultiEchoServer(int port) { this.port = port; } public void startServer() { ExecutorService executor = Executors.newCachedThreadPool(); ServerSocket serverSocket; try { serverSocket = new ServerSocket(port); } catch (IOException e) { System.err.println(e.getMessage()); // porta non disponibile return; } System.out.println("Server ready"); while (true) { try { Socket socket = serverSocket.accept(); executor.submit(new EchoServerClientHandler(socket)); } catch(IOException e) { break; // entrerei qui se serverSocket venisse chiuso } } executor.shutdown(); } public static void main(String[] args) { MultiEchoServer echoServer = new MultiEchoServer(1337); echoServer.startServer(); } 99 } Chiusura connessioni Per chiudere un ServerSocket o un Socket si utilizza il metodo close() Per ServerSocket, close() fa terminare la accept() con IOException Per Socket, close() fa terminare le operazioni di lettura o scrittura del socket con eccezioni che dipendono dal tipo di reader/writer utilizzato Sia ServerSocket sia Socket hanno un metodo isClosed() che restituisce vero se il socket è stato chiuso 100 25 27/03/2015 RMI Remote Method Invocation Middleware che porta i vantaggi della programmazione orientata gli oggetti nel contesto distribuito Si possono essere invocati metodi su oggetti remoti, per i quali si ha un riferimento remoto Aspetti innovativi passaggio dei parametri per valore (per oggetti NON REMOTI) e indirizzo (oggetti REMOTI) possibilità di download automatico dalla rete delle classi necessarie per la valutazione remota 101 Architettura client-server con RMI Caso tipico Server crea oggetti remoti, li rende visibili e aspetta che i client invochino metodi su di essi Client ottiene riferimenti a oggetti remoti e invoca metodi su di essi RMI fornisce il meccanismo con cui il server e i client comunicano per costituire l'applicazione distribuita 102 Architettura "esterna" Architettura esterna viene usato anche un normale server web per caricare (dinamicamente) le classi (in bytecode), da client a 103 104 26 27/03/2015 Funzionalità di RMI (1) Funzionalità di RMI (2) Localizzazione di oggetti remoti Gli oggetti remoti sono registrati presso un registro di nomi (rmiregistry) che fornisce una "naming facility", oppure Le operazioni passano come parametri e/o restituiscono riferimenti a oggetti remoti Comunicazione con oggetti remoti Client ottiene servizi dal server invocando metodi di oggetti remoti con una sintassi identica a quella per gli oggetti locali (residenti sulla stessa JVM), ma con una semantica un po' diversa Dynamic class loading essendo possibile passare oggetti ai metodi di oggetti remoti, oltre a trasmettere i valori dei parametri, RMI consente di trasferire il codice degli oggetti a run time (potrebbe trattarsi di un nuovo sottotipo) È un esempio di codice mobile 105 106 Definizioni Vincoli Le interfacce che definiscono le funzionalità degli oggetti remoti (cioè resi accessibili da altri oggetti non locali tramite il sistema RMI) devono ereditare da java.rmi.Remote I metodi definiti in tali interfacce devono dichiarare l'eccezione java.rmi.RemoteException 107 Oggetto remoto: oggetto i cui metodi possono essere invocati da una JVM diversa da quella in cui l'oggetto risiede Interfaccia remota: interfaccia che dichiara quali sono i metodi che possono essere invocati da una diversa JVM Server: insieme di uno o più oggetti remoti che, implementando una o più interfacce remote, offrono delle risorse (dati e/o procedure) a macchine esterne distribuite sulla rete Remote Method Invocation (RMI): invocazione di un metodo presente in una interfaccia remota implementata da un oggetto remoto (sintassi di invocazione 108 remota è identica a quella locale) 27 27/03/2015 Registry Architettura interna È un programma che viene lanciato dalla finestra dei comandi Il client colloquia con un proxy (ossia un «rappresentante») locale del server, detto stub rmiregistry -JDjava.rmi.server.hostname=0.0.0.0 È un programma di rete che ascolta su una porta, per default "1099 Occorre dargli comando per realizzare il binding tra l'oggetto locale esportato come remoto e il nome col quale ad esso si riferiscono i client lo stub rappresenta il server sul lato client implementa l'interfaccia del server è capace di fare forward di chiamate di metodi il client ha un riferimento locale all'oggetto stub Esiste anche un proxy del client sul lato server, detto skeleton è una rappresentazione del client chiama i servizi del server sa come fare forward dei risultati lo skeleton ha un riferimento all'oggetto 109 110 Architettura interna Architettura interna Il client colloquia con un proxy locale del server, detto stub lo stub rappresenta il server sul lato client implementa l'interfaccia del server è capace di fare forward di chiamate di metodi il client ha un riferimento locale all'oggetto stub Esiste anche un proxy del client sul lato server, detto skeleton è una rappresentazione del client chiama i servizi del server sa come fare forward dei risultati lo skeleton ha un riferimento all'oggetto 111 112 28 27/03/2015 Fasi di creazione di un sistema 1. Definire una INTERFACCIA remota per la comunicazione tra client e server 2. Definire un oggetto remoto e un'applicazione server convenzione: stesso nome dell'interf. e suffisso Impl 3. Definire client che usa un riferimento all'interfaccia remota per accedere all'oggetto remoto 4. Compilare ed eseguire 113 Creazione di interfaccia remota import java.rmi.Remote; import java.rmi.RemoteException; public interface HelloServer extends Remote { String sayHello() throws RemoteException; } Un'interfaccia remota 1. deve essere pubblica 2. deve estendere java.rmi.Remote 3. ogni metodo deve dichiarare java.rmi. RemoteException 4. ogni oggetto remoto passato come parametro o valore di ritorno deve essere dichiarato di tipo interfaccia remota 114 Lato server Lato server: esempio 1. Istanziare l'oggetto remoto obj che implementa l'interfaccia remota IR. 2. Creare l'oggetto stub usando la classe java.rmi.server.UnicastRemoteObject: import java.rmi.registry.Registry; import java.rmi.registry.LocateRegistry; import java.rmi.server.UnicastRemoteObject; public class HelloServerImpl implements HelloServer { public S tring sayHello() { return "Hello, world!"; IR stub = (IR) UnicastRemoteObject.exportObject(obj, 0); } 3. Registrare lo stub nel "registry" public static void main(String args[]) { l'oggetto obj potrebbe avere metodi che restituiscono riferimenti agli altri oggetti remoti, evitando così di dover passare attraverso il registry per accedere ad essi. Registry registry = LocateRegistry.getRegistry(); registry.rebind( NOME , stub); try { HelloServerImpl helloServer = new HelloServerImpl(); HelloServer helloServerStub = (HelloServer) UnicastRemoteObject.exportObject(helloServer, 0); // Registra il riferimento remoto (stub) dell'helloServer nel // registry e lo identifica con la stringa "Hello". Registry registry = LocateRegistry.getRegistry(); registry.rebind("Hello", helloServerStub); S ystem.err.println("Server ready"); Quando si esegue il server bisogna specificare come parametro della JVM: -Djava.rmi.server.codebase=file:classDir/ dove classDir è la directory che contiene i file compilati (deve essere raggiungibile sia dal client che dal registry!). In alternativa bisogna rendere i file compilati disponibili nel classpath del client e del registry. 115 } catch (Exception e) { System.err.println("Server exception: " + e.toString()); e.printStackTrace(); } 116 29 27/03/2015 package distrib1.rmi; evita il rischio di "bind"qualora import java.rmi.*; esista già un oggetto import java.rmi.server.*; registrato import java.rmi.registry.*; con lo stesso nome import java.net.*; public class PerfectTimeImpl extends UnicastRemoteObject implements PerfectTime { public long getPerfectTime() throws RemoteException { return System.currentTimeMillis(); } public PerfectTimeImpl() throws RemoteException { super(); //inutile, peraltro } public static void main (String args[]) throws Exception { System.setSecurityManager(new RMISecurityManager()); PerfectTime pt = new PerfectTimeImpl(); Naming.rebind ("//localhost/PerfectTimeServer", pt); System.out.println("Ready to do time"); stringa di registrazione: } 118 //host:porta/OggettoRem } Registry È un programma che viene lanciato dalla finestra dei comandi rmiregistry È un programma di rete che ascolta su una porta, per default "1099" Occorre dargli comando per realizzare il binding tra il l'oggetto locale esportato come remoto e il nome col quale ad esso si riferiscono i client 117 33 se registry sul server: //localhost/OggettoRem Uso dell'oggetto remoto Vita degli oggetti remoti Se main() termina, l'oggetto remoto registrato continua ad esistere finchè rmiregistry resta running Ecco perché è necessario fare rebind (potrebbe esistere un oggetto con lo stesso nome) Si può anche fare 119 package distrib1.rmi; import java.rmi.*; import java.rmi.registry.*; public class DisplayPerfectTime { public static void main(String[] args) throws Exception { System.setSecurityManager(new RMISecurityManager()); //lega oggetto locale a remoto PerfectTime t=(PerfectTime) Naming.lookup("//localhost/PerfectTimeServer"); for(int i=0; i<10; i++) System.out.println("Perfect time = "+ t.getPerfectTime()); } } 34 120 35 30 27/03/2015 Parametri Serializzazione Semantica dell'invocazione di un metodo remoto m(obj) se obj remoto, normale semantica se no, m opera su una copia serializzata di obj; eventuali modifiche allo stato di obj hanno effetto solo sulla copia, non sull'originale in pratica il passaggio di oggetti non remoti è per valore, mentre per gli oggetti remoti è per riferimento 121 E` la trasformazione di un oggetto in un byte stream E` possibile effettuarla su oggetti che implementano l'interfaccia Serializable Oggetti passati a, o ritornati da, un oggetto remoto devono implementare l'interfaccia Serializable se invece si passano riferimenti remoti, basta implementare Remote Stubs e skeletons effettuano automaticamente la serializzazione e deserializzazione si dice che fanno il "marshal" (schieramento) e "unmarshal" di argomenti e risultati 36 122 37 Scaricamento da remoto delle classi Che cosa dobbiamo fare noi? Il tool rmic (rmi compiler) crea i files necessari per stub e skeleton Uno dei principi di java è quello dello zero deployment Quando si usa RMI è possibile scaricare dal sito del server: rmic distrib1.rmi.PerfectTime genera due classi: Gli stub degli oggetti remoti Le classi corrispondenti ai parametri PerfectTime_Stub.class PerfectTime_Skel.class Per esempio, il client riceve un valore di ritorno da una chiamata remota che ha un certo tipo statico noto al client, ed un tipo dinamico non noto (in Java 2 solo stub) 123 38 124 39 31 27/03/2015 Scaricamento da remoto delle classi Security manager e file di policy Le classi possono essere scaricate attraverso un web server Per indicare il web server che si utilizzerà, si lancia il server con il seguente comando: java -Djava.rmi.server.codebase= "http://brahms:8000/" PerfectTimeImpl Perchè client e server possano istanziare correttamente le classi scaricate, è necessario configurare il security manager SecurityManager è una classe in java.lang che offre metodi per controllare la possibilità di accesso a varie risorse (file, socket,...) RMI usa un security manager per controllare i permessi di uso dei socket da parte di un'applicazione Un utente può definire le politiche di sicurezza editando un file di policy Questo impedisce alle classi scaricate di eseguire azioni non legali 125 40 Un esempio di file di policy connect ; permission java.net.SocketPermission * , accept ; permission java.io.FilePermission /tmp/* , 41 Come "far partire" il tutto? grant { permission java.net.SocketPermission * , 126 Far partire il registry Se necessario, far partire il web server Far partire il server indicando il file di policy da usare. Per esempio: read ; } java Djava.security.policy=./distrib1/rmi/permit distrib1.rmi.PerfectTimeImpl Far partire il/i client indicando il file di policy da usare 127 42 128 43 32
© Copyright 2024 Paperzz