Concorrenza multithreading in Java RICHIAMI SU PARALLELISMO. Parallelismo = multitasking. Sistemi multi-processore 27/03/2015
|
|
- Tommasina Buono
- 8 anni fa
- Visualizzazioni
Transcript
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());
Socket & RMI Ingegneria del Software - San Pietro
Socket & RMI Ingegneria del Software - San Pietro Socket È possibile trattare la comunicazione di rete allo stesso modo con cui è possibile trattare la lettura da file. La classe Socket rappresenta la
DettagliProgrammazione di rete in Java
Programmazione di rete in Java Reti di calcolatori Una rete di calcolatori è un sistema che permette la condivisione di dati informativi e risorse (sia hardware sia software) tra diversi calcolatori. Lo
DettagliProgrammazione distribuita
Programmazione distribuita 1 Architettura client-server È il modo classico di progettare applicazioni distribuite su rete Server offre un servizio "centralizzato" attende che altri (client) lo contattino
DettagliMultithreading in Java. Fondamenti di Sistemi Informativi 2014-2015
Multithreading in Java Fondamenti di Sistemi Informativi 2014-2015 Multithreading La programmazione concorrente consente di eseguire più processi o thread nello stesso momento. Nel secondo caso si parla
DettagliJava Virtual Machine
Java Virtual Machine programmi sorgente: files.java compilatore files.class bytecode linker/loader bytecode bytecode Java API files.class interprete macchina ospite Indipendenza di java dalla macchina
DettagliJava threads (2) Programmazione Concorrente
Java threads (2) emanuele lattanzi isti information science and technology institute 1/28 Programmazione Concorrente Utilizzo corretto dei thread in Java emanuele lattanzi isti information science and
DettagliProgrammazione concorrente in Java. da materiale di Carlo Ghezzi e Alfredo Mo8a
Programmazione concorrente in Java da materiale di Carlo Ghezzi e Alfredo Mo8a Parallelismo = mul
DettagliRMI Remote Method Invocation
RMI Remote Method Invocation [Pagina intenzionalmente vuota] (1 12 2004) slide 4:1/18 (p.106) Un applicazione RMI è un applicazione distribuita ad oggetti. Applicazione RMI tipica, strutturata in: server:
DettagliGESTIONE DEI PROCESSI
Sistemi Operativi GESTIONE DEI PROCESSI Processi Concetto di Processo Scheduling di Processi Operazioni su Processi Processi Cooperanti Concetto di Thread Modelli Multithread I thread in Java Concetto
DettagliProgrammazione concorrente in Java. Dr. Paolo Casoto, Ph.D. - 2012 1
+ Programmazione concorrente in Java 1 + Introduzione al multithreading 2 La scomposizione in oggetti consente di separare un programma in sottosezioni indipendenti. Oggetto = metodi + attributi finalizzati
DettagliTipi primitivi. Ad esempio, il codice seguente dichiara una variabile di tipo intero, le assegna il valore 5 e stampa a schermo il suo contenuto:
Tipi primitivi Il linguaggio Java offre alcuni tipi di dato primitivi Una variabile di tipo primitivo può essere utilizzata direttamente. Non è un riferimento e non ha senso tentare di istanziarla mediante
Dettagli12 - Introduzione alla Programmazione Orientata agli Oggetti (Object Oriented Programming OOP)
12 - Introduzione alla Programmazione Orientata agli Oggetti (Object Oriented Programming OOP) Programmazione e analisi di dati Modulo A: Programmazione in Java Paolo Milazzo Dipartimento di Informatica,
DettagliRegistri RMI. Massimo Merro Univ. Verona Programmazione di Rete 90 / 247
Registri RMI Per poter interagire con un server remoto, un client deve essere in possesso di una sua referenza remota (ovvero un oggetto stub). Un servizio di Naming è una risorsa centralizzata che può
DettagliOrganizzazione della lezione. Lezione 18 Remote Method Invocation - 6. (con callback) L accesso al registry per il rebind()
Organizzazione della lezione Lezione 18 Remote Method Invocation - 6 Vittorio Scarano Corso di Programmazione Distribuita (2003-2004) Laurea di I livello in Informatica Università degli Studi di Salerno
DettagliUniversità di Torino Facoltà di Scienze MFN Corso di Studi in Informatica. Programmazione I - corso B a.a. 2009-10. prof.
Università di Torino Facoltà di Scienze MFN Corso di Studi in Informatica Programmazione I - corso B a.a. 009-10 prof. Viviana Bono Blocco 9 Metodi statici: passaggio parametri, variabili locali, record
DettagliRMI. Java RMI RMI. G. Prencipe prencipe@di.unipi.it
Java Remote Method Invocation -- RMI G. Prencipe prencipe@di.unipi.it RMI RMI è una tecnologia JAVA che permette a una JVM di comunicare con un altra JVM per farle eseguire metodi È possibile che oggetti
Dettagli(VHUFLWD]LRQLGLEDVHVXOOH6RFNHWLQ-DYD 6RFNHWGLWLSRVWUHDP
(VHUFLWD]LRQLGLEDVHVXOOH6RFNHWLQ-DYD 6RFNHWGLWLSRVWUHDP D (FKR&OLHQWH6HUYHU Sviluppare un applicazione C/S in cui: il server attende una connessione da parte del client (su MDYDQHW6HUYHU6RFNHW), usa la
DettagliTest di unità con JUnit4
Test di unità con JUnit4 Richiamo sul test di unità Il test d unità è una metodologia che permette di verificare il corretto funzionamento di singole unità di codice in determinate condizioni. Nel caso
DettagliChat. Si ha un server in ascolto sulla porta 4444. Quando un client richiede la connessione, il server risponde con: Connessione accettata.
Chat Si ha un server in ascolto sulla porta 4444 Quando un client richiede la connessione, il server risponde con: Connessione accettata. Nome: Il client deve rispondere con lo user name A questo punto
DettagliRealizzazione di Politiche di Gestione delle Risorse: i Semafori Privati
Realizzazione di Politiche di Gestione delle Risorse: i Semafori Privati Condizione di sincronizzazione Qualora si voglia realizzare una determinata politica di gestione delle risorse,la decisione se ad
DettagliI file di dati. Unità didattica D1 1
I file di dati Unità didattica D1 1 1) I file sequenziali Utili per la memorizzazione di informazioni testuali Si tratta di strutture organizzate per righe e non per record Non sono adatte per grandi quantità
DettagliJava: Compilatore e Interprete
Java: Compilatore e Interprete Java Virtual Machine Il bytecode non è Linguaggio Macchina. Per diventarlo, deve subire un ulteriore trasformazione che viene operata dall interprete Java in modalità JIT
DettagliTelematica II 17. Esercitazione/Laboratorio 6
Multitasking e Multithreading Telematica II 17. Esercitazione/Laboratorio 6 Multitasking si riferisce all abilità di un computer di eseguire processi (jobs) multipli in maniera concorrente si ricorda che
DettagliT E O R I A D I P R O G E T T A Z I O N E D E L S O F T W A R E
Threading T E O R I A D I P R O G E T T A Z I O N E D E L S O F T W A R E Caratteristiche principali dei thread Consentono di eseguire elaborazioni simultanee in un programma scritto in C#. Possono essere
DettagliPronto Esecuzione Attesa Terminazione
Definizione Con il termine processo si indica una sequenza di azioni che il processore esegue Il programma invece, è una sequenza di azioni che il processore dovrà eseguire Il processo è quindi un programma
DettagliI Thread. I Thread. I due processi dovrebbero lavorare sullo stesso testo
I Thread 1 Consideriamo due processi che devono lavorare sugli stessi dati. Come possono fare, se ogni processo ha la propria area dati (ossia, gli spazi di indirizzamento dei due processi sono separati)?
DettagliProgrammazione concorrente in Java. da materiale di Carlo Ghezzi e Alfredo Motta
Programmazione concorrente in Java da materiale di Carlo Ghezzi e Alfredo Motta Parallelismo = multitasking Possiamo scrivere un programma in cui diverse attività (task) evolvono in parallelo da un punto
DettagliMultithreading in Java
Multithreading in Java Un programma sequenziale (single thread) class ABC {. public void main(..) {.. begin body end 2 Un programmamultithreaded Main Thread start start start Thread A Thread B Thread C
DettagliSistemi Operativi. Lez. 13: primitive per la concorrenza monitor e messaggi
Sistemi Operativi Lez. 13: primitive per la concorrenza monitor e messaggi Osservazioni I semafori sono strumenti particolarmente potenti poiché consentono di risolvere ogni problema di sincronizzazione
DettagliApplicazioni distribuite
Applicazioni distribuite Maurizio Cozzetto 1 agosto 2009 Un pò di teoria Ricordiamo che un'applicazione distribuita è un'applicazione composta da più programmi (almeno 2) posti in esecuzione su macchine
DettagliOttava Esercitazione. introduzione ai thread java mutua esclusione
Ottava Esercitazione introduzione ai thread java mutua esclusione Agenda Esempio 1 Concorrenza in Java: creazione ed attivazione di thread concorrenti. Esercizio 2 da svolgere Concorrenza in Java: sincronizzazione
DettagliOggetti Lezione 3. aspetti generali e definizione di classi I
Programmazione a Oggetti Lezione 3 Il linguaggio Java: aspetti generali e definizione di classi I Sommario Storia e Motivazioni Definizione di Classi Campi e Metodi Istanziazione di oggetti Introduzione
DettagliCon il termine Sistema operativo si fa riferimento all insieme dei moduli software di un sistema di elaborazione dati dedicati alla sua gestione.
Con il termine Sistema operativo si fa riferimento all insieme dei moduli software di un sistema di elaborazione dati dedicati alla sua gestione. Compito fondamentale di un S.O. è infatti la gestione dell
DettagliInizializzazione, Assegnamento e Distruzione di Classi
Inizializzazione, Assegnamento e Distruzione di Classi Lezione 9 Operazioni Automatiche In ogni programma C++ oggetti classe vengono gestiti automaticamente dal compilatore Inizializzati al momento della
DettagliProgrammazione a Oggetti Modulo B
Programmazione a Oggetti Modulo B Progetto Dott. Alessandro Roncato 4/10/2011 Progetto Da svolgere singolarmente Scadenza consegna: una settimana prima dello scritto; Valutazione in base a: Corretta compilazione
DettagliModulo 4: Ereditarietà, interfacce e clonazione
Modulo 4: Ereditarietà, interfacce e clonazione Argomenti Trattati: Classi, Superclassi e Sottoclassi Ereditarietà Ereditarietà ed Attributi Privati Override super Ereditarietà e Costruttori Polimorfismo
DettagliConcetto di Funzione e Procedura METODI in Java
Fondamenti di Informatica Concetto di Funzione e Procedura METODI in Java Fondamenti di Informatica - D. Talia - UNICAL 1 Metodi e Sottoprogrammi Mentre in Java tramite le classi e gli oggetti è possibile
DettagliUnicastRemoteObject. Massimo Merro Programmazione di Rete 103 / 124
UnicastRemoteObject Java RMI fornisce diverse classi base per definire server remoti: UnicastRemoteObject < RemoteServer < RemoteObject dove A < B significa che A è una sottoclasse di B. UnicastRemotObject
Dettagli13 - Gestione della Memoria nella Programmazione Orientata agli Oggetti
13 - Gestione della Memoria nella Programmazione Orientata agli Oggetti Programmazione e analisi di dati Modulo A: Programmazione in Java Paolo Milazzo Dipartimento di Informatica, Università di Pisa http://www.di.unipi.it/
Dettagli19. Introduzione al multi-threading
19. Introduzione al multi-threading Marco Faella Dip. Ing. Elettrica e Tecnologie dell'informazione Università di Napoli Federico II Corso di Linguaggi di Programmazione II I thread I thread, o processi
DettagliCoordinazione Distribuita
Coordinazione Distribuita Ordinamento degli eventi Mutua esclusione Atomicità Controllo della Concorrenza 21.1 Introduzione Tutte le questioni relative alla concorrenza che si incontrano in sistemi centralizzati,
Dettagli10.1. Un indirizzo IP viene rappresentato in Java come un'istanza della classe InetAddress.
ESERCIZIARIO Risposte ai quesiti: 10.1. Un indirizzo IP viene rappresentato in Java come un'istanza della classe InetAddress. 10.2. Un numero intero in Java è compreso nell'intervallo ( 2 31 ) e (2 31
DettagliMobilità di Codice. Massimo Merro Programmazione di Rete 128 / 144
Mobilità di Codice Abbiamo già visto come un dato host possa trasmettere un oggetto (serializzabile) ad un altro host. Quest ultimo potrà eseguire l oggetto pur non possedendo il bytecode della classe
DettagliProgrammazione a Oggetti Lezione 10. Ereditarieta
Programmazione a Oggetti Lezione 10 Ereditarieta Sommario Come definire sottoclassi Costruttori Abstract Classes Final Ereditarietà: promemoria Strumento tipico dell OOP per riusare il codice e creare
DettagliMODELLO CLIENT/SERVER. Gianluca Daino Dipartimento di Ingegneria dell Informazione Università degli Studi di Siena daino@unisi.it
MODELLO CLIENT/SERVER Gianluca Daino Dipartimento di Ingegneria dell Informazione Università degli Studi di Siena daino@unisi.it POSSIBILI STRUTTURE DEL SISTEMA INFORMATIVO La struttura di un sistema informativo
DettagliLa gestione dell input/output da tastiera La gestione dell input/output da file La gestione delle eccezioni
La gestione dell input/output da tastiera La gestione dell input/output da file La gestione delle eccezioni Autore: Prof. Agostino Sorbara ITIS "M. M. Milano" Autore: Prof. Agostino Sorbara ITIS "M. M.
DettagliSTRUTTURE DEI SISTEMI DI CALCOLO
STRUTTURE DEI SISTEMI DI CALCOLO 2.1 Strutture dei sistemi di calcolo Funzionamento Struttura dell I/O Struttura della memoria Gerarchia delle memorie Protezione Hardware Architettura di un generico sistema
DettagliDESIGN PATTERNS Parte 6. State Proxy
DESIGN PATTERNS Parte 6 State Proxy STATE Il Design Pattern State nasce dall'esigenza di poter gestire gli stati di una classe senza dover usare dei costrutti come gli Enum e quindi delle switch. Prendiamo
DettagliCorso di Reti di Calcolatori L-A
Università degli Studi di Bologna Facoltà di Ingegneria Corso di Reti di Calcolatori L-A Esercitazione 2 (svolta) Socket Java con connessione Luca Foschini Anno accademico 2009/2010 Esercitazione 2 1 Architettura
DettagliIntroduzione alle applicazioni di rete
Introduzione alle applicazioni di rete Definizioni base Modelli client-server e peer-to-peer Socket API Scelta del tipo di servizio Indirizzamento dei processi Identificazione di un servizio Concorrenza
DettagliJava Remote Method Invocation
Java Remote Method Invocation Programmazione in Rete e Laboratorio Comunicazione distribuita Port1 Java VM1 Java VM2 Port 2 Matteo Baldoni Dipartimento di Informatica Universita` degli Studi di Torino
DettagliEsercizio 1: trading on-line
Esercizio 1: trading on-line Si realizzi un programma Java che gestisca le operazioni base della gestione di un fondo per gli investimenti on-line Creazione del fondo (con indicazione della somma in inizialmente
DettagliSOMMARIO Coda (queue): QUEUE. QUEUE : specifica QUEUE
SOMMARIO Coda (queue): Specifica: interfaccia. Implementazione: Strutture indicizzate (array): Array di dimensione variabile. Array circolari. Strutture collegate (nodi). Prestazioni. Strutture Software
DettagliProgrammazione di sistemi distribuiti
Programmazione di sistemi distribuiti I Sistemi Distribuiti, per loro natura, prevedono che computazioni differenti possano essere eseguite su VM differenti, possibilmente su host differenti, comunicanti
DettagliUn esercizio d esame. Flavio De Paoli
Un esercizio d esame e note sulla gestione dei dati Flavio De Paoli Il testo (Appello 22 ottobre 2001) Una stazione di servizio dispone di n distributori di benzina. I clienti si presentano a uno dei distributori
DettagliSAPIENZA Università di Roma Facoltà di Ingegneria dell Informazione, Informatica e Statistica
SAPIENZA Università di Roma Facoltà di Ingegneria dell Informazione, Informatica e Statistica Esercitazioni di PROGETTAZIONE DEL SOFTWARE (Corsi di Laurea in Ingegneria Informatica ed Automatica ed Ingegneria
DettagliT 1. Per un processo con più thread di controllo, lo stato di avanzamento della computazione di ogni thread è dato da:
Un thread (o processo leggero) è una attività, descritta da una sequenza di istruzioni, che esegue all'interno del contesto di esecuzione di un programma. Un thread procede nella sua esecuzione per portare
DettagliArchitettura Client-Server
Architettura Client-Server 1. il client manda una richiesta al server 2. il server (in attesa) riceve la richiesta 3. il server esegue il servizio richiesto (generando un thread concorrente) 4. il server
DettagliCorso sul linguaggio Java
Corso sul linguaggio Java Modulo JAVA6 A1 I file testo 1 Prerequisiti Programmazione base in Java Utilizzo di classi e oggetti Modello produttore consumatore Operazioni logiche su struttura file 2 1 Introduzione
DettagliTerza Esercitazione. Unix - Esercizio 1. Unix System Call Exec Java Introduzione Thread
Terza Esercitazione Unix System Call Exec Java Introduzione Thread Stefano Monti smonti@deis.unibo.it Unix - Esercizio 1 Scrivere un programma C con la seguente interfaccia:./compilaedesegui
DettagliScheduling della CPU. Sistemi multiprocessori e real time Metodi di valutazione Esempi: Solaris 2 Windows 2000 Linux
Scheduling della CPU Sistemi multiprocessori e real time Metodi di valutazione Esempi: Solaris 2 Windows 2000 Linux Sistemi multiprocessori Fin qui si sono trattati i problemi di scheduling su singola
DettagliIl costrutto monitor [Hoare 74]
Il monitor 1 Il costrutto monitor [Hoare 74] Definizione: Costrutto sintattico che associa un insieme di operazioni (entry, o public) ad una struttura dati comune a più processi, tale che: Le operazioni
DettagliInformatica 3. Informatica 3. LEZIONE 6: Il controllo dell esecuzione. Lezione 6 - Modulo 1. Errori durante l esecuzione. Il controllo dell esecuzione
Informatica 3 Informatica 3 LEZIONE 6: Il controllo dell esecuzione Modulo 1: La gestione delle eccezioni Modulo 2: Programmazione concorrente Lezione 6 - Modulo 1 La gestione delle eccezioni Politecnico
DettagliParte II: Reti di calcolatori Lezione 12
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A. 2014-15 Parte II: Reti di calcolatori Lezione 12 Giovedì 16-04-2015 1 Confronto architetture C/S e
DettagliFONDAMENTI di INFORMATICA L. Mezzalira
FONDAMENTI di INFORMATICA L. Mezzalira Possibili domande 1 --- Caratteristiche delle macchine tipiche dell informatica Componenti hardware del modello funzionale di sistema informatico Componenti software
DettagliLaboratorio di Sistemi Distribuiti Leonardo Mariani
Laboratorio di Sistemi Distribuiti Leonardo Mariani ELECTION ALGORITHMS In molti sistemi distribuiti un processo deve agire da (o svolgere un ruolo particolare) per gli altri processi. Spesso non è importante
DettagliJava:Struttura di Programma. Fabio Scanu a.s. 2014/2015
Java:Struttura di Programma Fabio Scanu a.s. 2014/2015 Altre Attenzioni da riservare Java è Case Sensitive: La variabile «a» e la variabile «A» sono diverse Java ha alcune regole di scrittura: I nomi delle
Dettagli3 - Variabili. Programmazione e analisi di dati Modulo A: Programmazione in Java. Paolo Milazzo
3 - Variabili Programmazione e analisi di dati Modulo A: Programmazione in Java Paolo Milazzo Dipartimento di Informatica, Università di Pisa http://www.di.unipi.it/ milazzo milazzo di.unipi.it Corso di
DettagliCenni di programmazione distribuita in C++ Mauro Piccolo piccolo@di.unito.it
Cenni di programmazione distribuita in C++ Mauro Piccolo piccolo@di.unito.it Socket Nei sistemi operativi moderni i servizi disponibili in rete si basano principalmente sul modello client/server. Tale
DettagliSiti web centrati sui dati Architettura MVC-2: i JavaBeans
Siti web centrati sui dati Architettura MVC-2: i JavaBeans 1 ALBERTO BELUSSI ANNO ACCADEMICO 2009/2010 Limiti dell approccio SEVLET UNICA La servlet svolge tre tipi di funzioni distinte: Interazione con
DettagliIl Sistema Operativo. C. Marrocco. Università degli Studi di Cassino
Il Sistema Operativo Il Sistema Operativo è uno strato software che: opera direttamente sull hardware; isola dai dettagli dell architettura hardware; fornisce un insieme di funzionalità di alto livello.
DettagliAutomatizzare i compiti ripetitivi. I file batch. File batch (1) File batch (2) Visualizzazione (2) Visualizzazione
Automatizzare i compiti ripetitivi I file batch Anno accademico 2000-01 1 Spesso capita di dover eseguire ripetutatmente una data sequenza di comandi Introdurli uno a uno da tastiera è un processo lento
DettagliSistemi Operativi. Processi GESTIONE DEI PROCESSI. Concetto di Processo. Scheduling di Processi. Operazioni su Processi. Processi Cooperanti
GESTIONE DEI PROCESSI 4.1 Processi Concetto di Processo Scheduling di Processi Operazioni su Processi Processi Cooperanti Concetto di Thread Modelli Multithread I thread in diversi S.O. 4.2 Concetto di
DettagliIntroduzione. Classificazione di Flynn... 2 Macchine a pipeline... 3 Macchine vettoriali e Array Processor... 4 Macchine MIMD... 6
Appunti di Calcolatori Elettronici Esecuzione di istruzioni in parallelo Introduzione... 1 Classificazione di Flynn... 2 Macchine a pipeline... 3 Macchine vettoriali e Array Processor... 4 Macchine MIMD...
DettagliIl Sistema Operativo
Il Sistema Operativo Il Sistema Operativo Il Sistema Operativo (S.O.) è un insieme di programmi interagenti che consente agli utenti e ai programmi applicativi di utilizzare al meglio le risorse del Sistema
DettagliUniversità di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A. 2015-16. Pietro Frasca.
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A. 2015-16 Pietro Frasca Lezione 15 Martedì 24-11-2015 Struttura logica del sottosistema di I/O Processi
DettagliIntroduzione. Coordinazione Distribuita. Ordinamento degli eventi. Realizzazione di. Mutua Esclusione Distribuita (DME)
Coordinazione Distribuita Ordinamento degli eventi Mutua esclusione Atomicità Controllo della Concorrenza Introduzione Tutte le questioni relative alla concorrenza che si incontrano in sistemi centralizzati,
Dettagli4 3 4 = 4 x 10 2 + 3 x 10 1 + 4 x 10 0 aaa 10 2 10 1 10 0
Rappresentazione dei numeri I numeri che siamo abituati ad utilizzare sono espressi utilizzando il sistema di numerazione decimale, che si chiama così perché utilizza 0 cifre (0,,2,3,4,5,6,7,8,9). Si dice
DettagliProgettAzione tecnologie in movimento - V anno Unità 4 - Realizzare applicazioni per la comunicazione in rete
ProgettAzione tecnologie in movimento - V anno Unità 4 - Realizzare applicazioni per la comunicazione in rete Compito in classe proposto Realizzare un applicazione C/S per trasferire al Client il contenuto
DettagliUso di JUnit. Fondamenti di informatica Oggetti e Java. JUnit. Luca Cabibbo. ottobre 2012
Fondamenti di informatica Oggetti e Java ottobre 2012 1 JUnit JUnit è uno strumento per assistere il programmatore Java nel testing JUnit consente di scrivere test di oggetti e classi Java i test sono
DettagliFunzioni in C. Violetta Lonati
Università degli studi di Milano Dipartimento di Scienze dell Informazione Laboratorio di algoritmi e strutture dati Corso di laurea in Informatica Funzioni - in breve: Funzioni Definizione di funzioni
DettagliComputazione multi-processo. Condivisione, Comunicazione e Sincronizzazione dei Processi. Segnali. Processi e Threads Pt. 2
Computazione multi-processo Avere più processi allo stesso momento implica/richiede Processi e Threads Pt. 2 Concorrenza ed efficienza Indipendenza e protezione dei dati ma deve prevedere/permettere anche:
DettagliArchitettura MVC-2: i JavaBeans
Siti web centrati sui dati Architettura MVC-2: i JavaBeans Alberto Belussi anno accademico 2008/2009 Limiti dell approccio SEVLET UNICA La servlet svolge tre tipi di funzioni distinte: Interazione con
DettagliParola chiave extends
Il Linguaggio Java Ereditarietà Ereditarietà L'ereditarietà permette di creare nuove classi sulla base di classi esistenti In particolare, permette di riusare il codice (metodi e campi); aggiungere nuovi
DettagliArduino: Programmazione
Programmazione formalmente ispirata al linguaggio C da cui deriva. I programmi in ARDUINO sono chiamati Sketch. Un programma è una serie di istruzioni che vengono lette dall alto verso il basso e convertite
DettagliLa prima applicazione Java. Creazione di oggetti - 1. La prima applicazione Java: schema di esecuzione. Gianpaolo Cugola - Sistemi Informativi in Rete
La prima applicazione Java Programma MyFirstApplication Il programma visualizza una finestra vuota sullo schermo. Importo il package delle classi usate nel seguito. Dichiaro la classe MyFirstApplication
DettagliSoluzione dell esercizio del 2 Febbraio 2004
Soluzione dell esercizio del 2 Febbraio 2004 1. Casi d uso I casi d uso sono riportati in Figura 1. Figura 1: Diagramma dei casi d uso. E evidenziato un sotto caso di uso. 2. Modello concettuale Osserviamo
DettagliSynchronized (ancora)
Synchronized (ancora) Riscriviamo l esempio di prima. Usiamo una struttura modulare, con una classe Notificatore che ha opportuni metodi. La classe ha due campi privati, la lista buftext e un suo thread.
DettagliPer scrivere una procedura che non deve restituire nessun valore e deve solo contenere le informazioni per le modalità delle porte e controlli
CODICE Le fonti in cui si possono trovare tutorial o esempi di progetti utilizzati con Arduino si trovano nel sito ufficiale di Arduino, oppure nei forum di domotica e robotica. Il codice utilizzato per
DettagliProgettazione : Design Pattern Creazionali
Progettazione : Design Pattern Creazionali Alessandro Martinelli alessandro.martinelli@unipv.it 30 Novembre 2010 Progettazione : Design Pattern Creazionali Aspetti generali dei Design Pattern Creazionali
DettagliParte II: Reti di calcolatori Lezione 10
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A. 2013-14 Pietro Frasca Parte II: Reti di calcolatori Lezione 10 Giovedì 3-04-2014 1 Reti per la distribuzione
DettagliRichiesta pagina PHP (es: index.php)
PHP PHP = personal home page SERVER Richiesta pagina PHP (es: index.php) Server Web (Apache) in ascolto sulla porta 80, si accorge che la pagina richiesta è una pagina PHP in base all'estensione o con
DettagliIl sistema di I/O. Hardware di I/O Interfacce di I/O Software di I/O. Introduzione
Il sistema di I/O Hardware di I/O Interfacce di I/O Software di I/O Introduzione 1 Sotto-sistema di I/O Insieme di metodi per controllare i dispositivi di I/O Obiettivo: Fornire ai processi utente un interfaccia
Dettagli2.5. L'indirizzo IP identifica il computer di origine, il numero di porta invece identifica il processo di origine.
ESERCIZIARIO Risposte ai quesiti: 2.1 Non sono necessarie modifiche. Il nuovo protocollo utilizzerà i servizi forniti da uno dei protocolli di livello trasporto. 2.2 Il server deve essere sempre in esecuzione
DettagliL API socket ed i daemon
L API socket ed i daemon Massimo Bernaschi Istituto per le Applicazioni del Calcolo Mauro Picone Consiglio Nazionale delle Ricerche Viale del Policlinico, 137-00161 Rome - Italy http://www.iac.cnr.it/
DettagliCapitolo 3. L applicazione Java Diagrammi ER. 3.1 La finestra iniziale, il menu e la barra pulsanti
Capitolo 3 L applicazione Java Diagrammi ER Dopo le fasi di analisi, progettazione ed implementazione il software è stato compilato ed ora è pronto all uso; in questo capitolo mostreremo passo passo tutta
DettagliLuca Mari, Sistemi informativi applicati (reti di calcolatori) appunti delle lezioni. Architetture client/server: applicazioni server
Versione 30.5.05 Sistemi informativi applicati (reti di calcolatori): appunti delle lezioni Architetture client/: applicazioni 1 La logica dei socket Abbiamo visto che un applicazione client si connette
Dettagliappunti delle lezioni Architetture client/server: applicazioni server
Sistemi informativi applicati (reti di calcolatori): appunti delle lezioni Architetture /: applicazioni 1 La logica dei Abbiamo visto che un applicazione si connette e comunica con un applicazione mediante
DettagliIntroduzione al Linguaggio C
Introduzione al Linguaggio C File I/O Daniele Pighin April 2009 Daniele Pighin Introduzione al Linguaggio C 1/15 Outline File e dati Accesso ai file File I/O Daniele Pighin Introduzione al Linguaggio C
Dettagli1. RETI INFORMATICHE CORSO DI LAUREA IN INGEGNERIA INFORMATICA SPECIFICHE DI PROGETTO A.A. 2013/2014. 1.1 Lato client
RETI INFORMATICHE - SPECIFICHE DI PROGETTO A.A. 2013/2014 1. RETI INFORMATICHE CORSO DI LAUREA IN INGEGNERIA INFORMATICA SPECIFICHE DI PROGETTO A.A. 2013/2014 Il progetto consiste nello sviluppo di un
Dettagli