Concorrenza multithreading in Java RICHIAMI SU PARALLELISMO. Parallelismo = multitasking. Sistemi multi-processore 27/03/2015

Транскрипт

1 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 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 Sistemi multi-processore In passato erano costosi e riservati ad applicazioni speciali Oggi sistemi multiprocessore sono largamente disponibili a livello di massa 4 1

2 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 ) Caso 1: Task singolo Caso 2: Due task 5 6 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 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 7 8 2

3 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 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(); che semplificano la costruzione di sw multitasking ritorna 3 immediatamente 12 3

4 Esempio public class HelloThread extends Thread public void run() { System.out.println("Hello from a thread!"); public static void main(string args[]) { (new HelloThread()).start(); Esempio da Java Tutorial 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

5 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 definire 2. Creare istanza ListSorter concsorter = new ListSorter(list1); 3. Creare thread Thread mythread = new Thread(concSorter); 4. Attivare metodo run, attraverso metodo start() mythread.start() ereditare da qualche classe 17 Esempio public class HelloRunnable implements Runnable { public void run() { System.out.println("Hello from a thread!"); public static void main(string args[]) { (new Thread(new HelloRunnable())).start(); 18 Ciclo di vita di un thread (semplificato) start born ready fine I/O scheduler fine lock running I/O lock blocked dead costruito 19 Dettagli vari 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.: 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; Ogni thread ha priorità (compresa fra Thread.Min_Priority e Thread.Max_Priority, di default Thread.Norm_Priority) La priorità è usata dallo scheduler per decidere quali thread sono running 5

6 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 = 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? All'inizio saldo = 100 Esempio di run 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= Thread1 continua e esegue saldo= 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; 22 Es: Interferenza 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 23 Soluzione: Sequenze atomiche 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

7 Imporre ordinamenti 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) 25 Come rendere i metodi "atomici" 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; 26 Esempio: contatore sincronizzato public class SynchronizedCounter { private int c = 0; public synchronized void increment() { c++; public synchronized void decrement() { c--; public synchronized int value() { return c; 27 Metodi synchronized Java associa un intrinsic lock (monitor) a ciascun oggetto che ha almeno un metodo synchronized Ogni estensione di object può avere metodi synchronized Quando un metodo synchronized è invocato: 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 NB: un metodo non synchronized non è mai 28 bloccato. 7

8 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 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

9 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 33 Deadlock 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 34 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(); new Thread(new Runnable() {public void run() {joe.bow(al);).start(); 35 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

10 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 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 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 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. 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 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

11 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 task («va in wait») 42 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; notify(); risveglia un task sospeso 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 notify notifyall waiting wait start born ready fine I/O scheduler fine lock running I/O lock blocked dead 44 11

12 Attenzione ai dettagli Un thread che e' andato in wait puo' essere risvegliato solo da un notify o notifyall 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 Ancora dettagli 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; 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 in sospeso MA uno solo guadagna il lock Schema produttore/consumatore con buffer unitario public synchronized String take() { // Wait until message is // available. while (empty) { try { wait(); catch (InterruptedException e) { // Toggle status. empty = true; 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. // Notify producer that // status has changed. notifyall(); 47 return message; notifyall(); 48 12

13 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 Deadlock producer/consumer con notify 3 threads P1,P2,P3 produttori; C1,C2 C3 consumatori, un Buffer b. (leggono/scrivono sullo stesso Buffer) 1. P1: b.put(..), che scrive ed esce. 2. P2: b.put(..) e va in wait (b pieno) 3. P3: b.put(..) e va in wait (b pieno) 4. C1: b.take(), che comincia l'esecuzione. Ora b è locked 5. C2, C3: b.take(): b e' locked, quindi si bloccano 6. C1 finisce di eseguire b.take(..), che chiama notify ed esce 7. 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 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! 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: 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. 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. 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

14 Problemi con oggetti mutabili Da 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 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 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() { //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 synchronized void invert() { red = red; green = green; blue = blue; name = "Inverse of " + name; 53 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 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: si può 54 definire un SynchronizedRGB immutabile 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. 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

15 Esempio 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 final public class ImmutableRGB { Soluzione 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 int getrgb() { return ((red << 16) (green << 8) blue); public String getname() { return name; public ImmutableRGB invert() { return new ImmutableRGB(255 - red, green, blue, "Inverse of " + name); 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; 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 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 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

16 Esempio: Al, Joe e l'inchino 1: Creazione dei thread 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(); oggetti Friend devono acquisire i locks di entrambi i partecipanti prima di proseguire con l'inchino. BowLoop e' una classe di prova che fa inchinare per sempre Al e Joe ad intervalli d tempo casuali 61 class Friend { Friend: bow e bowback 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 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; 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

17 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()); Codice completo PARTE 2 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 3 public void bowback(friend bower) { System.out.format("%s: %s has" + " bowed back to me!%n", this.name, bower.getname()); 65 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(); 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 thread 67 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

18 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 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 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 71 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()); 18

19 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 class Counter { private int c = 0; Esempio class SynchronizedCounter { private int c = 0; Esempio con Oggetti atomici import java.util.concurrent.atomic.atomicinteger; public void increment() { c++; public void decrement() { c--; public int value() { return c; PROBLEMI DI INTERFERENZA! public synchronized void increment() { c++; public synchronized void decrement() { c--; public synchronized int value() { return c; NO INTERFERENZA MA POTENZIALI DEADLOCK! Alternativa dei synchronized statement è soluzione molto «fine» che porta facilmente a errori. Cosa fare? 75 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 complicazioni dei syncronized statements 76 19

20 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 La rete come architettura fisica programmabile Poter allocare computazioni su nodi fisici diversi e consentire il coordinamento tra le computazioni sui diversi nodi Nodi fisici e nodi logici 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

21 Architettura client-server È 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 Middleware 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) Middleware Socket in Java package java.net, classi: Socket, ServerSocket Client e server comunicano (pacchetti TCP) attraverso socket (attacchi) socket client socket server 83 Endpoint individuati da: indirizzo IP numero di porta (uno per ogni applicazione) 84 21

22 Comunicazione client-server Socket come stream 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 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 Un oggetto di tipo Socket e' associato a uno stream di input, da cui leggere, e uno stream di output su cui scrivere Metodi getinputstream e getoutputstream. E' possibile stabilire connessioni TCP o UDP. Attenzione a UDP che non ha gestione degli errori (puo' 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 Aprire connessione (lato client) 1. Aprire un socket specificando indirizzo IP e numero di porta del server Socket socket = new Socket(" ", 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

23 Esempio di server: EchoServer 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(); 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. System.out.println("Closing sockets"); in.close(); // chiudo gli stream e il socket out.close(); Se il server riceve una riga quit socket.close(); chiuderà la connessione e terminerà l' serversocket.close(); esecuzione Esempio di client: LineClient 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(); Si crei un client che si colleghi, con protocollo TCP, alla porta 1337 dell'indirizzo IP 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 chiude la connessione

24 Creare EchoServer e LineClient Serializzazione public class LineClient { public class EchoServer { private String ip; private int port; private int port; private ServerSocket serversocket; public void startclient() throws IOException { public EchoServer(int port) { public LineClient(String ip, int port) { this.port = port; this.ip = ip; this.port = port; public static void main(string[] args) { EchoServer server = new public static void main(string[] args) { EchoServer(1337); LineClient client = new try { LineClient(" ", 1337); server.startserver(); try { catch (IOException e) { client.startclient(); System.err.println(e.getMessage()); catch (IOException e) { System.err.println(e.getMessage()); 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

25 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

26 RMI Remote Method Invocation Architettura client-server con RMI 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 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 Architettura esterna Architettura "esterna" viene usato anche un normale server web per caricare (dinamicamente) le classi (in bytecode), da client a

27 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 105 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 106 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 Definizioni 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 remota è 108 identica a quella locale) 27

28 Registry È un programma che viene lanciato dalla finestra dei comandi rmiregistry -J- Djava.rmi.server.hostname= È 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 109 Architettura interna Il client colloquia con un proxy (ossia un «rappresentante») 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 110 Architettura interna 111 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

29 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 1. Istanziare l'oggetto remoto obj che implementa l'interfaccia remota IR. 2. Creare l'oggetto stub usando la classe java.rmi.server.unicastremoteobject: IR stub = (IR) UnicastRemoteObject.exportObject(obj, 0); 3. Registrare lo stub nel "registry" 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); 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 Lato server: esempio import java.rmi.registry.registry; import java.rmi.registry.locateregistry; import java.rmi.server.unicastremoteobject; public class HelloServerImpl implements HelloServer { public String sayhello() { return "Hello, world!"; public static void main(string args[]) { 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); System.err.println("Server ready"); catch (Exception e) { System.err.println("Server exception: " + e.tostring()); e.printstacktrace();

30 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 package distrib1.rmi; import java.rmi.*; import java.rmi.server.*; import java.rmi.registry.*; import java.net.*; evita il rischio di "bind"qualora esista già un oggetto registrato con lo stesso nome 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: //host:porta/oggettorem se registry sul server: //localhost/oggettorem 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 Uso dell'oggetto remoto 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());

31 Parametri 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 Serializzazione 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 Che cosa dobbiamo fare noi? Il tool rmic (rmi compiler) crea i files necessari per stub e skeleton rmic distrib1.rmi.perfecttime genera due classi: PerfectTime_Stub.class PerfectTime_Skel.class (in Java 2 solo stub) Scaricamento da remoto delle classi Uno dei principi di java è quello dello zero deployment Quando si usa RMI è possibile scaricare dal sito del server: Gli stub degli oggetti remoti Le classi corrispondenti ai parametri 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

32 Scaricamento da remoto delle classi 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= " PerfectTimeImpl Perchè client e server possano istanziare correttamente le classi scaricate, è necessario configurare il security manager Questo impedisce alle classi scaricate di eseguire azioni non legali Security manager e file di policy 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 Un esempio di file di policy grant { permission java.net.socketpermission *, connect ; permission java.net.socketpermission *, accept ; permission java.io.filepermission /tmp/*, read ; Come "far partire" il tutto? Far partire il registry Se necessario, far partire il web server Far partire il server indicando il file di policy da usare. Per esempio: java Djava.security.policy=./distrib1/rmi/permit distrib1.rmi.perfecttimeimpl Far partire il/i client indicando il file di policy da usare