CORSO DI SISTEMI OPERATIVI Università di Milano, a.a. 1996-97 INTRODUZIONE AL LINGUAGGIO JAVA Roberto Polillo (Queste slides sono una espansione delle slides di G.Prini per lo stesso corso)

RIFERIMENTI The Java Series (Addison-Wesley): K.Arnold, J.Gosling, The Java Programming Language J.Gosling, B:Joy, G:Steel, The Java Language Specification T.Lindholm, F.Yellin, The Java Virtual Machine Specification …..

INDICE Parte 1 Introduzione al sistema di program- mazione Java Parte 2 Programmazione a oggetti Parte 3 Il linguaggio Java

INTRODUZIONE AL SISTEMA DI PROGRAMMAZIONE JAVA PARTE 1 INTRODUZIONE AL SISTEMA DI PROGRAMMAZIONE JAVA

CARATTERISTICHE

CHE COS’È JAVA È un linguaggio (e relativo ambiente di programmazione) definito dalla Sun Microsystems … … per permettere lo sviluppo di applicazioni sicure, performanti e robuste su piattaforme multiple, in reti eterogenee e distribuite (Internet)

IL LINGUAGGIO JAVA: CARATTERISTICHE Semplice e orientato agli oggetti Interpretato Architetturalmente neutro e portabile Robusto Distribuito Sicuro Dinamico Ad elevate prestazioni Concorrente (multithread)

SEMPLICE E OO Sintassi simile a C e C++ (facile da imparare) Elimina i costrutti più "pericolosi" di C e C++ aritmetica dei puntatori (de)allocazione esplicita della memoria strutture (struct) definizione di tipi (typedef) preprocessore (#define) Aggiunge garbage collection automatica Conserva la tecnologia OO di base di C++ Rivisita C++ in alcuni aspetti (C++--==)

INTERPRETATO Il compilatore produce un codice di tipo intermedio per una “Java Virtual Machine” (“byte-code”) ... … che viene interpretato codice sorgente byte code compilatore interprete

BYTECODE: ESEMPIO void spin ( ) { int i; for (i = 0; i < 100; i++) { ; } } 0 iconst_0 // push int constant 0 1 istore_1 // store into local 1 (i=0) 2 goto 8 // first time, don’t increment 5 iinc 1 1 // increment local i by 1 (i++) 8 iload_1 // push local 1 (i) 9 bipush 100 // push int constant (100) 11 if_icmplt 5 // compare, loop if < (I<100) 14 return // return void when done

ARCHITETTURALMENTE NEUTRO Il byte-code è indipendente dall’architettura hardware (ANDF: Architecture Neutral Distribution Format) Pertanto, un programma bytecode può essere eseguito su qualsiasi sistema su cui giri un ambiente run-time Java

ESEMPIO Sistema tradizionale Sistema ANDF eseguibile compilatore macchina A compilatore macchina A codice sorgente compilatore macchina B eseguibile macchina B ……. Sistema ANDF compilatore macchina A interprete macchina A codice sorgente byte code compilatore macchina B interprete macchina B ……. …….

ESEMPIO Il formato dei dati è specificato esattamente, e non “di minima”, come nel C: byte 8 bit complemento a 2 short 16 bit “ int 32 bit “ long 64 bit “ float 32 bit IEEE 754 floating double 64 bit “ char 16 bit Unicode

PORTABILE Il sistema Java (compilatore + interprete + librerie run-time) è facilmente portabile su piattaforme diverse codice sorgente byte code compilatore interprete S.O. libreria il compilatore Java è scritto in Java l’ambiente run-time è scritto in ANSI C con interfacce standard (POSIX) verso il sistema operativo nessuna “implementation dependency”

ROBUSTO Controlli estensivi a compile-time e a run-time, per rilevare gli errori quanto prima possibile (es.: type checking) Per questo, le caratteristiche insicure di C e C++ sono rimosse: Nessuna gestione esplicita dei puntatori (no aritmetica dei puntatori, no malloc e free esplicite, …) Gestione della memoria con garbage collection Array e stringhe “veri” Verifica del byte-code a load-time

DISTRIBUITO Pensato per essere eseguito in rete L’ambiente run-time incorpora funzioni di rete (sia di basso livello: TCP/IP, che di alto livello: HTTP, …) La rete è facilmente accessibile (come i file locali)

SICURO L’ambiente di esecuzione si protegge da bytecode potenzialmente “ostile” Esempi: il bytecode viene verificato prima dell’interpretazione (“theorem prover”), in modo da essere certi di alcune sue caratteristiche gli indirizzamenti alla memoria nel bytecode sono risolti sotto il controllo dell’interprete Dopo la verifica del bytecode, alcune proprietà sono note: non ci sono overflow o underflow nello stack degli operandi I tipi dei parametri di tutte le istruzioni bytecode sono corretti gli accessi ai campi degli oggetti sono legali. Dopo la verifica, l’interprete può saltare questi controlli, e quindi sarà molto più veloce.

COMPILE-LOAD-RUN Rete Loader delle classi Verifica del byte-code Sorgente Java Interprete Compilatore Ambiente run-time Byte-code Java hardware

ELEVATE PRESTAZIONI La verifica del bytecode permette di saltare molti controlli a run-time: l’interprete è pertanto efficiente Per maggiore efficienza, possibilità compilazione on-the-fly del bytecode in codice macchina

COMPILAZIONE ON-THE-FLY Rete Loader delle classi Verifica del byte-code Sorgente Java Interprete Compilatore Generatore di codice Ambiente run-time Byte-code Java hardware

DINAMICO Il codice è eseguibile anche in assenza di alcuni moduli: … le classi necessarie per la esecuzione di un programma Java possono essere caricate e collegate dinamicamente quando servono Esempio: nuove release di moduli caricabili automaticamente dalla rete quando servono

CONCORRENTE Multithreading parte integrante del linguaggio: Applicazioni interattive più facili a scriversi Migliore "reattività" (anche se non real-time) Esempio: caricamento asincrono di immagini nei browser di rete riduce i tempi di attesa

RICCO La Standard Library Java contiene una ricca collezione di classi e di metodi preconfezionati: Language support Utilities Input/output Networking Abstract Window Toolkit (AWT)

JAVA E INTERNET

WEB BROWSER E SERVER Server abc.com Server xyz.com Client Hyperlink program to xyz.com Disk Disk HTTP Server HTTP Server HTTP used over this TCP connection Internet

URL: Uniform Resource Locator <protocollo> :// <nome del server> <nome del file> Esempio: http://www.dsi.unimi.it/DSI/corsi/programmi/F28005/index.html deve essere risolto in un indirizzo internet (IP) con l’aiuto di un Domain Name Server (DNS)

HTML: ESEMPIO <HTML> <HEAD> <TITLE> Esempio </TITLE> Esempio </HEAD> Testo <BODY> DSI <P> Testo <A HREF=“http://www.dsi.unimi.it”> DSI </A> </BODY> </HTML>

APPLET JAVA Sono programmi Java riferiti da link in pagine HTML Vengono caricati e interpretati dal browser (se questo supporta Java) Permettono di “animare” le pagine web

HTML con APPLET: ESEMPIO <HEAD> <TITLE> Esempio </TITLE> Esempio </HEAD> Testo <BODY> Hallo! <P> Testo <APPLET CODE=“HelloWorld.class WIDTH=300 HEIGHT=80> Qui c’è un applet che ti saluta </APPLET> </BODY> </HTML> testo che esce se il browser non supporta gli applet

JAVA BROWSER rete TCP / IP ftp client http client java loader interprete HTML interprete JAVA I/O library local disk UI library

UN NUOVO PARADIGMA: NETWORK COMPUTING Approccio tradizionale DATI PROGRAMMI RETE PC Network computing PROGRAMMI E DATI load and run RETE NC

PROGRAMMAZIONE A OGGETTI PARTE 2 PROGRAMMAZIONE A OGGETTI

PARADIGMI DI PROGRAMMAZIONE

RIFLESSIONI SULLA PROGRAMMAZIONE Programmare è un mestiere strano: costruire cose immateriali sempre piene di difetti, che costano un sacco di soldi e sono fatte di migliaia di frasi scritte da gente particolare per macchine molto stupide che richiedono precisione assoluta e che cambiano di continuo ...

I DUE PARADIGMI DELLA PROGRAMMAZIONE Ci sono essenzialmente due modi diversi di descrivere il mondo: come un sistema di processi (“modello procedurale”) come un sistema di cose (“modello a oggetti”)

ESEMPIO: UNA MACCHINA PER SPREMERE LE ARANCE Rube Goldberg, Inventions of Professor Lucifer Butts, 1932

IL MODELLO PROCEDURALE: ALCUNI TEMI TIPICI Processi, sequenze di esecuzione Concetto di “controllo” Trasformazioni, funzioni Flow-charts Tracciatori, program profilers Copertura topologica Complessità strutturale Il problema dei goto Linguaggi strutturati Programmazione top-down Astrazione procedurale ….

LA MACCHINA DI VON NEUMANN “… nel progettare una sequenza codificata, quello che bisogna avere innanzitutto in mente non è l’apparenza originale della sequenza, ma piuttosto il suo funzionamento e il suo continuo cambiamento mentre il processo che essa controlla procede nel suo corso. … È dunque consigliabile incominciare la progettazione dalla fine, e cioè progettare per prima cosa il corso del processo e la relazione delle sue fasi successive con il codice che cambia, e quindi estrarre la sequenza codificata come operazione succes-siva.” Goldstine & Von Neumann, 1947

SPAGHETTI E STRUTTURA

RIUSABILITÀ NEI LINGUAGGI PROCEDURALI Dalle librerie di “subroutines” alle librerie di procedure/funzioni Esempio: C int fun (int i, float r) { int j; …. } “ASTRAZIONE FUNZIONALE”

IL MODELLO PROCEDURALE: LINGUAGGI Fortran 1956-1957 Cobol 1960 Basic 1963-1964 Pascal 1972 C 1972

UN BLOCCO INTELLETTUALE? “… Questi “linguaggi di Von-Neumann” creano dei blocchi stradali mentali enormi e non necessari nel pensare i programmi e nel creare le combinazioni di alto livello richieste da una metodologia di programmazione veramente potente. …” John Backus, 1978

IL MODELLO A OGGETTI: ALCUNI TEMI TIPICI Dall’astrazione funzionale alla “data abstraction” Costruire “cose”, non processi Società di entità attive, cooperanti, riusabili Dalla computazione alla comunicazione e alla delega Classificare il mondo: classi, sottoclassi, istanze (“esemplari”) Bottom-up, non top-down

IL MODELLO A OGGETTI: LINGUAGGI Simula Smalltalk Eiffel C++ Java

IL PARADIGMA A OGGETTI

Un oggetto è una coppia [stato,funzioni] OGGETTI: CHE SONO MAI? Versione informatica degli oggetti "reali" Dotati di una loro propria "individualità" Capaci di interagire per scambio di messaggi Caratterizzati da proprietà dati: ne descrivono lo “stato” funzioni: ne descrivono il “comportamento” Un msg modifica stato e attiva comportamenti Un oggetto è una coppia [stato,funzioni]

ESEMPIO: UN’AUTOMOBILE Funzioni Dati: - Avviati - Targa - Fermati - Colore - Accelera - Velocità - … - Livello benzina - ...

“Tipo di dati astratti” (ADT) CLASSI una classe ha un nome, e contiene due tipi di membri: campi e metodi campi metodo “Tipo di dati astratti” (ADT)

OGGETTI Un oggetto è una istanza (“esemplare”) di una classe, che viene creato (“instanziato”) dinamica-mente MIV5678 MIK1178 BO8956 Automobile a b c valori variabili Due esemplari della stessa classe sono distinguibili soltanto per il loro stato (il valore dei loro campi), mentre il comportamento è sempre identico

CLASSI: ESEMPIO (JAVA) class Automobile { string targa; int velocità; color colore; … public void Avviati () { ….. } public void Fermati () { nome classe campi metodi

OGGETTI: ESEMPIO (JAVA) class Automobile { …. } Automobile a, b, c; a = new Automobile(); b = new Automobile(); c = new Automobile(); a.Avviati(); dichiara, non crea crea

INCAPSULAMENTO Alcuni attributi (dati e metodi) sono pubblici (cioè visibili "all'esterno") Altri attributi sono privati dell'oggetto, e quindi “nascosti” all’esterno (“information hiding”) Le parti private sono modificabili senza effetti per gli interlocutori dell'oggetto Propagazione delle modifiche assai contenuta Stimolo al riutilizzo di oggetti ("black-box")

ESEMPIO: AUTOMOBILE Parti "visibili" (interfaccia pubblica): accesso a "ciò che l'auto può fare" volante, combinazione volante-freno (ev. a mano) blocchetto di accensione, oppure manovella pedale dell'acceleratore, acceleratore automatico Parti "nascoste" (implementazione): "come l'auto fa ciò che si può fare" meccanica dello sterzo e dell'alimentazione elettromeccanica dell'avviamento sistema di alimentazione e accensione

INCAPSULAMENTO: APPROCCI Approccio "puro" lo stato è privato, e lo si può modificare solo attraverso quei metodi che sono stati dichiarati pubblici . Esempio: Fermati() Approccio di Java anche le componenti dello stato possono essere dichiarate pubbliche e modificate dall'esterno Esempio: velocita=0

INTERAZIONI TRA OGGETTI Gli oggetti possono comunicare e interagire mediante scambio di messaggi attraverso le loro interfacce pubbliche (stato o funzioni) Per mezzo di un messaggio un oggetto può chiedere un'informazione a un altro oggetto, causarne un cambiamento di stato, oppure delegargli un'attività Un messaggio in arrivo viene trattato dal metodo omonimo del ricettore, il quale "si attiva" per rispondere, per cambiare di stato, oppure per intraprendere un'attività

ESEMPIO: UN'AUTOVETTURA Il sistema antiskid durante una frenata invia periodicamente un messaggio alle ruote per "leggere" la loro velocità di rotazione Il galleggiante nel serbatoio del carburante invia messaggi all'indicatore di livello sul cruscotto per "scrivervi" un nuovo stato Il volante tornando alla posizione di riposo invia un messaggio al comando meccanico dell'indicatore di direzione per delegargli il compito di interrompere l'eventuale segnale lampeggiante (i.e. di "togliere la freccia")

OGGETTI COMPOSTI Un oggetto può essere costituito da altri oggetti automobile ruota carrozzeria motore

UN SISTEMA A OGGETTI a b c d g f e main chiamata di un metodo di b

SISTEMI A OGGETTI Società di entità attive, cooperanti, riusabili Bottom-up, non top-down Visione locale, non globale “Comportamento emergente”

ESEMPIO: ARTIFICIAL LIFE

UNA DOMANDA IMPORTANTE I computer possono fare di più di quanto venga loro indicato?

EREDITARIETÀ È il meccanismo che consente di derivare una sottoclasse da una classe data Una sottoclasse si ottiene per aggiunta, per occultamento o per ridefinizione di uno o più membri rispetto alla classe di partenza (che diventa una superclasse della nuova classe) Esempio: automobile taxi StartTassametro EndTassametro Licenza

ESEMPIO class Taxi extends Automobile { int licenza; public void StartTassametro() { … } public void EndTassametro () { nuovo campo nuovi metodi

ESEMPI Implementazione di un'interfaccia grafica classe "finestra": attributo privato "sfondo" e metodo "cambia-sfondo" sottoclasse "finestra-nera": attributo privato "sfondo" ridefinito con il valore costante "nero", metodo "cambia-sfondo" occultato Libreria di algebra lineare: classe "matrice": metodo "determinante" generico sottoclasse "matrice-diagonale": metodo "determinante" che moltiplica tra di loro gli elementi sulla diagonale Dichiarazione dei redditi classe "contribuente": quadri del modello 740 base classe "autonomi": aggiunta del membro "quadro-E"

GERARCHIA DI CLASSI Generalizzazione Specializzazione instanziazione

ESEMPIO obiect Veicolo VeicoloSenza Motore Veicolo A Motore Motocicletta Automobile Taxi

AGGIUNGERE SOTTOCLASSI obiect Veicolo VeicoloSenza Motore Veicolo A Motore Motocicletta Automobile Altro Taxi

RIDEFINIZIONE DEI METODI Veicolo A Motore Noleggia Motocicletta Automobile Aereo Noleggia ereditano il metodo utilizza la versione locale

POLIMORFISMO “Ciò che vale per una classe, vale anche per le sue sottoclassi. Se una proprietà viene ridefinita, quando la uso viene selezionata la versione corretta” Esempio: Quando uso un metodo di un oggetto, non so: a quali livelli è definito quale tra i metodi omonimi nella gerarchia verrà usato

VISIBILITÀ DEI NOMI Il msg inviato all’oggetto nome gerarchia di classi Il msg inviato all’oggetto risale nella gerarchia fino a trovare una definizione b.nome oggetto b oggetto a

PROGRAMMAZIONE A OGGETTI E TASSONOMIA Nel paradigma a oggetti, l’attenzione del programmatore è spostata dalla creazione di processi di computazione alla creazione di tassonomie del sistema in esame Osservazioni: Per descrivere un sistema sono possibili tassonomie diverse, a seconda degli obbiettivi La tassonomia è un’arte difficile

ESEMPI ALTERNATIVI Automobile Spider Berlina Segmento C Automobile Benzina Diesel Segmento A Segmento B Segmento C

EREDITARIETÀ MULTIPLA Meccanismo che consente di derivare sottoclassi da due o più classi Il problema degli omonimi Java non implementa ereditarietà multipla Taxi Automobile Mezzo Pubblico

RIUSO Classi specifiche sviluppo interno Classi specializzate dal fornitore di classi Classi generali col linguaggio Linguaggio

PARTE 3 IL LINGUAGGIO JAVA

INDICE Caratteristiche lessicali Tipi Strutture di controllo Classi Ereditarietà Interfacce Packages Struttura di un’applicazione Multithreading

CARATTERISTICHE LESSICALI

ALFABETO I sorgenti Java utilizzano il codice standard internazionale a 16 bit Unicode, che comprende gli alfabeti più diffusi: arabo, greco, ebraico, cirillico, thai, katakana, hiragana, cinese, coreano, e molti altri (http://www.unicode.org) I programmi Java possono essere scritti con altre codifiche (es. ASCII), ma devono essere convertiti in Unicode prima di essere compilati Sequenze di escape: /udddd (d: 0-9, a-f, A-F)

FORMATO Il formato di un sorgente Java è libero: gli spazi (blank, tab, newline, form feed) non sono significativi, tranne che per separare i token fra loro, o nei letterali

COMMENTI Tre diversi stili: /* Commento tradizionale, eventualmente su più linee, non nidificato */ // Commento su di una sola linea /** Commento di documentazione". */ Solo immediatamente prima di una dichiarazione di classe, interfaccia, metodo o campo, e viene incluso nella documentazione generabile automa- ticamente a partire dal codice sorgente (es.: javadoc)

ESEMPIO /** Questo è un esempio di commento di documentazione per una classe “Automobile” * @see Ruota * @see Carrozzeria * @author Roberto * @version 1.0 */

TAGS Tag Descrizione Si applica a @see Nome di classe Classe, metodo, campo collegata @author Nome autore Classe @version Versione Classe @param Nome e descrizione Metodo parametro @return Descrizione del valore Metodo di ritorno @exception Nome e descrizione Metodo eccezione

IDENTIFICATORI Sono composti da “lettere Java” e “cifre Java”, e devono iniziare con una “lettera Java” Possono essere di qualsiasi lunghezza Attenzione: sono lettere e cifre Unicode! _ e $ sono considerate lettere caratteri con codifica diversa (es. maiuscole e minuscole) sono considerati diversi (anche se hanno la stessa rappresentazio-ne)

PAROLE CHIAVE Le seguenti keywords non possono essere usate come identificatori: abstract double int super boolean else interface switch break extends long synchronized byte final native this case finally new throw catch float package throws char for private transient class (goto) protected try (const) if public void continue implements return volatile default import short while do instanceof static Note: - const e goto sono riservate, ma non usate - anche i letterali null, true, false sono riservati

KEYWORDS JAVA E C Java C byte boolean final try catch finally throw throws private public protected transient synchronized native abstract import class extends instanceof implements interface package this super new true° false° null° struct union enum signed unsigned extern auto register sizeof typedef char int short long float double void if else for while do switch case default break continue return goto°° volatile static const°° ° letterali, non keywords °° riservate ma non usate in Java

TIPI

TIPI: SINTESI TIPI KEYWORD NOTE boolean: boolean true, false byte short int long char 8 bit interi in compl. a 2 16 bit 32 bit 64 bit 16 bit Unicode Primitivi numerici interi float double 32 bit IEEE 754 64 bit floating-point classi class Reference interfacce interface array Null

TIPI (segue) Linguaggio fortemente tipato: il tipo di una espressione è sempre noto a compile-time Linguaggio a oggetti non puro: non tutti i tipi sono classi Rispetto al C, non esistono: signed, unsigned, long double, enum, puntatori, struct, union, typedef

TIPI PRIMITIVI: ESEMPI Dichiarazioni: int i, float f; Inizializzazioni: double d = 3.14; Espressioni: i + 5 j = i++ Nota: byte e short vengono sempre promossi a int prima di essere valutati Assegnamenti: i = j + 5; Essenzialmente, gli stessi operatori del C

CLASSI dichiarazione di classe: class Automobile { <campi> <metodi> } dichiarazione di oggetto: Automobile a; creazione di oggetto: a = new Automobile(); uso dell’oggetto: … a.campo … … a.metodo(…) ... a nul a heap I campi vengono inizializzati

CLASSI: ESEMPIO class Safe { public int doorNumber = 123; private boolean locked = true; private int combination = 456; public boolean isLocked() { return (locked) } public void unLock (int thisCombination) { if (thisCombination == combination) unLock(); private void unLock() { locked = false; private void setCombination(int setting) { combination = setting; Safe() { } /* costruttore */ Safe (int door) { /* altro costruttore (overloading) */ doorNumber = door; setCombination(doorNumber); 123 Safe aSafe; aSafe = new Safe(); Safe anotherSafe; anotherSafe = new Safe(1927) ... aSafe.doorNumber=456; aSafe.unLock(1997);

CLASSI “WRAPPER” Tutti i tipi primitivi tranne byte e short hanno una classe corrispondente nel package java.lang: Boolean, Integer, Long, Character, Float, Double, (“wrapper class”) Tale classe definisce metodi e costanti utili per quel tipo, ad esempio: Classe: Character Costanti (static): MIN_VALUE, MAX_VALUE, … Metodi (static): isDefined, isLowerCase, IsUpperCase, isTitleCase, isDigit, isLetter, isLetterOrDigit, isSpace, isJavaLetter,isJavaLetterOrDigit, toLowerCase, toUpperCase, toTitleCase, digit, forDigit

INTERFACCE In sostanza, sono liste di metodi di cui non è definita l’implementazione, ma solo l’interfaccia La loro implementazione deve essere realizzata da una classe

ESEMPIO public interface AudioClip { void play (); /* avvia i'esecuzione */ void loop (); /* esegui ciclicamente una audio clip */ void stop (); /* interrompi l'esecuzione */ } class MyAudio implements AudioClip { void play () { <codice che implementa play> } void loop () { <codice che implementa loop> } void stop () { <codice che implementa stop> } } class YourAudio implements AudioClip { <codice> } I metodi possono essere public o abstract, gli attributi public, static o final

ARRAY In Java gli array sono oggetti I componenti di un array: sono tutti dello stesso tipo possono essere di tipo primitivo o reference (inclusi altri array) sono indicizzati con int (indice primo elemento: 0), con controllo di validità degli indici a run-time Esempio: int[ ] a; /* dichiarazione */ /* anche int a[ ]; */ a = new int[3]; /* creazione */ a[0] = 0; /* uso */ a null a heap

ARRAY (segue) La lunghezza di un array è fissata al momento della sua creazione, e non può essere cambiata… ... ma si può assegnare un nuovo array di diversa lunghezza all’array reference: int[ ] a = new int[3]; a = new int[5]; a heap heap a

ARRAY DI ARRAY short [ ] [ ] a; /* array di array di short */ short a[ ] [ ]; /* equivalente */ a = new short [3][2]; a = new short [3][ ]; a heap a[2][0] a heap null

ARRAY DI OGGETTI class Automobile { public int targa; public int velocità; …. } Automobile[ ] a=new Automobile[3]; a heap a[2].targa

STRUTTURE DI CONTROLLO

STRUTTURE DI CONTROLLO: SINTESI Sequenza Selezione if switch Iterazione for while do-while Salto break uscita da un blocco continue continua un loop return da un metodo Gestione ecce- try-catch- zioni finally-throw Non c’è goto!

SINTASSI if ( condition ) switch ( intexpr ) { boolean, non integer! if ( condition ) switch ( intexpr ) { statement; case intexpr : statement; [else [case intexpr : statement; statement; ] ... default : statement; ] } while ( condition ) statement; for ( init; condition; increment ) do statement; while ( condition );

USCITE break [label]; continue [label]; return expr; label: statement

ESEMPIO label: for (i =0 , j=0 ; i<10 && j<20; i++ , j++) { for (z=0 ; z<100 ; z++) { switch (expr) { case tag: statements; break; /* esce da switch */ ..... default: statements; break label; /* esce da label */ } if (z==15) continue; /* prosegue il for z */ if (z==i+j) continue label; /* prosegue da label */ }

GESTIONE ECCEZIONI È una struttura di controllo che permette la gestione di condizioni di errore senza complicare la struttura del codice (codici di ritorno, flag, …) Quando si rileva una condizione anomale (eccezione), essa viene segnalata (throw), e il controllo viene automaticamente trasferito al gestore della eccezione, che la tratta

STRUTTURA try-catch-finally qui dentro viene segnalata la eccezione, con throw e try blocco-0 catch (exception_type1 id) blocco-1 catch (exception_type2 id) block-2 … finally blocco-n blocco-1 blocco-n blocco-0 blocco-2 exception_type1 exception_type2

LA SEGNALAZIONE DELLE ECCEZIONI Le eccezioni possono venire segnalate: dal sistema run-time, es.: ArithmeticException IndexOutOfBoundsException SecurityException NullPointerException ... dal programma: throw e;

CHE COSA SONO LE ECCEZIONI Le eccezioni sono oggetti, di una sottoclasse della classe Throwable: Object Throwable Exception Error Runtime Exception checked exceptions, definite dall’utente unchecked exceptions

LA DICHIARAZIONE throws type method(args) throws MyException { …. throw new MyException(…) } Permette al compilatore di controllare quali eccezioni vengono segnalate fornisce documentazione all’utente del metodo

CLASSI

DICHIARAZIONE DI CLASSI [Doc comment] [Modifiers] class ClassName [ extends SuperClassName] [ implements InterfaceName [, InterfaceName] ...] {ClassBody} Doc comment commento di documentazione Modifiers abstract, final, public, ... extends la classe è sottoclasse di un'altra implements la classe realizza una o più interfacce ClassBody i campi e i metodi della classe

ESEMPIO Dichiarazione di una classe MyClass public class MyClass { int i; /* campo */ public void Add_to_i (int j) { /* metodo */ i = i+j; } public MyClass () { /* metodo costruttore: ha lo i = 10; stesso nome della classe */ Creazione e uso di una istanza di MyClass MyClass mc; /* dichiarazione, non creazione */ mc = new MyClass(); /* creazione: l'attributo i vale 10 */ mc.i++; /* ora i vale 11 */ mc.Add_to_i(10); /* e ora i vale 21 */

DICHIARAZIONE DI CAMPI [DocComment] [Modifiers] Type VariableDeclarator [,VariableDeclarator]… ; Esempio: static int i = 5, j = 7, a[]; Doc comment commento di documentazione Modifiers static, public, protected,private, final, ... Type tipo (primitivo o reference) VariableDeclarator identificatore (anche di array), con eventuale inizializzazione

DICHIARAZIONE DI METODI [Doc comment] [Modifiers] ReturnType MethodName (ParameterList) [throws ClassType [,ClassType] … ] { MethodBody } Doc comment commento di documentazione Modifiers static, public,protected,private, abstract, final,native, ... ReturnType può essere un tipo primitivo o reference, o void (nessun valore di ritorno). Deve esse- re sempre specificato (ma non per i co- struttori) ParameterList un metodo ha sempre un numero fisso di argomenti (ma è possibile l’ overloading)

ESEMPIO int base; public int power (int n) { int i, p; p=1; for (i=1; i<=n; ++i) p=p*base; return p; } campo della classe variabili locali valore della funzione

IL MODIFICATORE static Campi e metodi dichiarati static, sono associati alla classe e non a una particolare istanza class MyClass { static int a; … static void MyMethod() { a = a+1; } Pertanto: esiste una sola copia di un campo statico, condiviso da tutte le istanze della classe; non occorre istanziare un oggetto per usare un membro statico; metodi statici possono accedere solo a membri statici della classe Sono qualificati con il nome della classe, e non della istanza MyClass.a =MyClass.a + 1;

ESEMPIO class Safe { static int LastSerialNumber; public int SerialNumber; int SetCombination; …. Safe(int Combination) { SerialNumber = LastSerialNumber++; SetCombination = Combination; } public static StartNewSeriesFrom (int Start) { LastSerialNumber = Start; Safe.LastSerialNumber(100000); /* inizializza il numero di serie */ Safe MySafe = new Safe(23456); /* crea una Safe di SerialNumber = 100001 e combinazione 23456 */ … MySafe.SerialNumber …. Il costruttore Safe fa sì che ogni istanza di Safe abbia un SerialNumber unico

VARIABILI LOCALI Le variabili locali a un metodo: sono visibili solo dal corpo del metodo vengono allocate (nello stack di run-time) alla chiamata e deallocate all’uscita del metodo non vengono inizializzate automaticamente (diversamente dai campi di una classe) Non si può accedere a una variabile a cui non si sia prima assegnato un valore (e viene segnalato in compilazione !) Esempio: int i; if ( cond ) { i = 55; … } i++; /* compile-time error */

LA KEYWORD this Se una variabile locale ha lo stesso nome di un membro della sua classe, questo risulta invisibile (“shadowing”) … … a meno di usare la keyword this, che denota l’oggetto corrente Esempio: class MyClass { int x, y, z; /* membri */ void MyMethod (int x) { /* parametro */ int y; /* variabile locale */ y=x+1; /* y è la variabile locale, x è il parametro */ z=this.x; /* this.x è il membro x */ … } NB: Poichè this denota un oggetto, non si può usare con membri dichiarati static

PASSAGGIO DI PARAMETRI A UN METODO Tutti i tipi primitivi sono passati per valore Anche i riferimenti a oggetti di tipo reference sono passati per valore Es: int i; SomeObject obj = new SomeObject(); MyMethod( i, obj ); …. Void MyMethod (int j, SomeObject o) { j = j+1; /* non altera i, passato per valore */ o = null; /* non altera obj, che si riferisce ancora all’oggetto */ } heap obj o i j

COSTRUTTORI Sono metodi che vengono chiamati quando si crea una istanza di una classe; non ritornano alcun valore Se non definisco alcun costruttore, per default viene fornito il costruttore vuoto: class MyClass { … MyClass() { } } Possono essere overloaded; non ha senso che siano static

ESEMPIO: OVERLOADING Dichiarazione di una classe MyNewClass public class MyNewClass { int i; public MyNewClass () { i = 10; } public MyNewClass (int j) { i = j; } ..... Creazione di una istanza di MyNewClass MyNewClass mc0, mc1; /* dichiarazione, non creazione */ mc0 = new MyNewClass(); /* creazione: l'attributo i vale 10 */ mc0.i++; /* ora i vale 11 */ mc1= new MyNewClass(20); /* creazione: l'attributo i vale 20 */ mc1.i++; /* ora i vale 21 */ Overloading: metodi omonimi devono essere distinguibili per la quantità e/o per il tipo degli argomenti

DISTRUZIONE DI OGGETTI Java non supporta distruttori di oggetti: gli oggetti non possono essere distrutti esplicitamente Un oggetto privo di riferimenti incidenti non è più accessibile, e la memoria che esso occupa può essere "riciclata" dal garbage collector, che opera in un thread indipendente a bassa priorità String s; /* dichiarazione, non creazione */ s = new String ("abc"); /* creazione: s punta a "abc" */ s = "def"; /* "abc" non è più puntata da s */

FINALIZZATORI DI OGGETTI Un oggetto "riciclabile" (cioè privo di puntatori incidenti) potrebbe trovarsi in uno stato poco "pulito" (ad es. potrebbe aver aperto dei file che non sono stati ancora chiusi) Prima di riciclarlo, il garbage collector invoca il metodo finalize dell’oggetto, es.: protected void finalize () throws Throwable { ... super.finalize(); /* meglio metterlo sempre */ } Il metodo finalize esiste sempre: se non è stato definito, viene ereditato da Object;

IL MODIFICATORE native Un metodo è dichiarato native quando il suo codice è dipendente dalla piattaforma (ad esempio, è scritto in un altro linguaggio) Esempio: public native void seek(long pos) throws IOException ; non deve essere specificato il body

EREDITARIETA’

SOTTOCLASSI In Java, una classe può estendere una sola altra classe (ereditarietà singola) Una sottoclasse eredita i campi e i metodi della sua superclasse che non siano dichiarati private e che non siano costruttori, e li può usare come se fossero dichiarati al suo interno Un oggetto di una sottoclasse può essere usato ovunque può essere usato un oggetto della sua superclasse

lecito, perchè “gatto” è una sottoclasse di “animale” ESEMPIO class Animale { Gatto Fufi = new Gatto(); float Peso; Animale creatura = Fufi; … void Mangia () { … } } class Mammifero extends Animale { int BattitoCardiaco; // eredita Peso void Respira() { … } // eredita mangia class Gatto extends Mammifero { // eredita BattitoCardiaco, Peso, Mangia, Respira void FaLeFusa() { … } lecito, perchè “gatto” è una sottoclasse di “animale”

“COME” ESTENDERE UNA CLASSE Attenzione alla differenza fra la relazione “è un” e la relazione “ha un” : solo la prima può definire una sottoclasse Esempio: Un cerchio può essere definito mediante il suo centro e il suo raggio, ma sarebbe scorretto definire una classe cerchio come sottoclasse di punto: class punto { class cerchio extends punto { double x; int y; double raggio; … ... } }

SHADOWING E OVERRIDING shadowing un campo di una sottoclasse può “nascon- dere” un campo omonimo di una sua superclasse overriding un metodo di una sottoclasse può “sovra- scrivere” un metodo di ugual “segnatura” e ugual ReturnType di una sua super- classe Esempio: class SuperClass { int i; void m(int k) {…} … } class Subclass extends Superclass { long i: void m(int n) {…} nasconde sovrascrive

POLIMORFISMO class Animale { Gatto Fufi = new Gatto(); … Animale creatura =Fufi; void Mangia () { … } creatura.Mangia(); … } class Mammifero extends Animale { class Gatto extends Mammifero { void Mangia() { … } ... viene eseguito il metodo Mangia della classe Gatto! (binding dinamico: il metodo da chiamare viene selezionato a run-time)

LA KEYWORD super per denotare un membro nascosto (campo shadowed o metodo overridden non static), si può usare la keyword super Esempio: class SuperClass { int i; … } class Subclass extends SuperClass { long i: i = super.i +1;

CASTING Gatto Fufi = new Gatto(); Animale creatura; ... creatura = Fufi; /* ok */ Fufi = creatura; /* errore di compilazione: tipi incompatibili */ Fufi = (Gatto)creatura; /* ok, ma solo perchè creatura è un gatto: se non lo fosse, il controllo a run-time segnalrebbe una eccezione */

COSTRUTTORI NELLE SOTTOCLASSI Nel costruttore di una sottoclasse, è corretto, come prima cosa, chiamare il costruttore della superclasse Esempio: class SubClass extends SuperClass { SubClass() { super(); <altre operazioni> }

IL MODIFICATORE abstract Una classe è dichiarata abstract quando contiene almeno un metodo abstract (cioè senza body) Una classe abstract non può essere instanziata: occorre sovrascrivere tutti i metodi abstract in una sottoclasse, e istanziare la sottoclasse Esempio: abstract class a { … abstract int m(int k); } class b extends a { ... int m(int n) { … } sovrascrive, fornendo la implementazione del metodo

IL MODIFICATORE final final ha tre significati diversi: campo final non può essere modificato: è un campo costante (deve essere inizializzato) Esempio: final int i = 5; metodo final non può essere sovrascritto classe final non può avere sottoclassi (quindi i suoi metodi sono implicitamente final)

se non fosse final , potrebbe essere sovrascritto ! METODI final: ESEMPIO class Password { private int passwd; final boolean validatePassword(String s) { ….. } ... se non fosse final , potrebbe essere sovrascritto !

INTERFACCE

INTERFACCE Una interface è una struttura sintattica dotata di nome, che racchiude la specifica della segnatura e del ReturnType dei metodi di una classe non ancora implementata Esempio: interface Driveable { boolean startEngine(); void stopEngine(); float accelerate(float acc); boolean turn(Direction dir); }

IMPLEMENTAZIONE DI UNA INTERFACCIA Una interfaccia può essere implementata da una (o più) classi: interface Driveable { boolean startEngine(); ... } interface Automobile implements Driveable { boolean startEngine() { ... } // una particolare implementazione …. interface Motorcycle implements Driveable { boolean startEngine() { ... } // un’altra implementazione

POLIMORFISMO Esempio: Driveable vehicle; /* variabile di tipo interfaccia; le possiamo assegnare qualunque oggetto di una classe che implementa l’interfaccia */ Automobile auto = new Automobile(); Motorcycle moto = new Motorcycle(); ... vehicle = auto; vehicle.startEngine(); /* polimorfismo: è il metodo di Automobile */ … vehicle = moto; vehicle.startEngine(); /* polimorfismo: è il metodo di Motorcycle */

EREDITARIETA’ MULTIPLA Una classe può implementare più di una interfaccia interface Driveable { interface Rentable { void startEngine(); void startRental(); void stopEngine(); void endRental(); float accelerate(float acc); int book(Date start, Date end); boolean turn(Direction dir); } } class AvisCar implements Driveable, Rentable { void startEngine() { … } void startRental() { … } …

SUPERINTERFACCE Una interfaccia può estendere una o più altre interfacce, es.: interface a extends b, c, d { …. } Ogni classe che implementa un’interfaccia deve estendere anche tutte le sue superinterfacce

INTERFACCE vs CLASSI abstract Le interfacce sono simili a classi che abbiano soltanto: metodi abstract campi static e final (cioè costanti) A differenza delle classi, le interfacce permettono di realizzare una forma di ereditarietà multipla

PACKAGES

PACKAGES Più classi o interfacce interrelate possono essere riunite in un package, dotato di nome Esempio: classe o interfaccia c e b d a MyPackage

NOMI DI CLASSI Il nome di una classe (o di una interfaccia) va sempre qualificato con il nome del package a cui appartiene, tranne quando viene usato all’interno dello stesso package Esempio: aaa.bbb.ccc.MyClass all’interno di aaa.bbb.ccc basta questo

NOMI DI PACKAGE Il nome di un package può essere composto da più identificatori separati da “.”: roberto.utilities.internet Per evitare che package di produttori diversi abbiano lo stesso nome, si suggerisce di far iniziare il nome del package con il dominio Internet del produttore (invertito, e con il nome di più alto livello tutto maiuscolo): IT.unimi.dsi.roberto.utilities.internet nome di dominio

PACKAGES STANDARD

LO STATEMENT package Specifica che le classi che seguono apparten-gono a un certo package Deve apparire (una sola volta) all’inizio di una unità di compilazione Esempio: a.java package p; le classi a,b,c appartengono al package p class a {.. Se lo statement è omesso, la classe appartiene al package anonimo class b {... class c {..

LO STATEMENT import Per evitare di usare sempre nomi completi di classi, si può usare lo statement import Esempio: import java.util.Date; class MyClass { class MyClass { java.util.Date today; Date today; … ... } } Note: import java.util.* importa tutte le classi del package java.util java.lang.* è sempre importato implicitamente

PACKAGE E DIRECTORY Molti ambienti Java mappano i nomi dei package sui pathname del file system (compilatore e class loader) Esempio: aaa.bbb.ccc.MyClass aaa/bbb/ccc/MyClass package classe directories file pathname

CLASS PATH Per indicare al class loader da quale directory partire per la mappatura può essere usata la variabile di ambiente CLASSPATH Esempio (Unix): setenv CLASSPATH /classi : /usr/roberto/classi : . java.lang.Math /java.lang.Math.class nome completo della classe pathname assoluto

VISIBILITA’ Classi e interfacce sono visibili all’interno del package in cui sono dichiarate; sono visibili all’esterno del package solo se dichiarate public public class a { … public interface b { … Membri (campi e metodi) sono visibili quando: la loro classe è visibile e il loro modificatore li rende visibili

VISIBILITA’ DI CAMPI E METODI Modificatore Visibilità private solo nella classe in cui è definito nessuno (default) solo nelle classi del package protected classi nel package e sottoclassi (stesso package o altri package) public tutte le classi più visibile NB: I membri di una interfaccia sono sempre pubblici

ESEMPIO package pac class b { class a {... private int i; class c {... private void m( ) {…} int j; void n( ) {…} public int k; public p( ){…} protected int i; protected void m( ){…} class c {... visibile class e extends d {... class d extends b {... class d extends b {...

PROGETTARE LA VISIBILITA’ Quando progettiamo una classe dobbiamo pensare a due tipi di utenti: quelli che utilizzeranno la classe per realizzare delle applicazioni quelli che estenderanno la classe per realizzare sottoclassi I primi useranno i membri public; i secondi anche i membri protected Le interfacce public e protected vanno progettate con cura

DUE TIPI DI UTENTI ESTENDE USA class a { private int i; private void m( ) {…} int j; void n( ) {…} public int k; public p( ){…} protected int i; protected void m( ){…} USA ESTENDE interfaccia package pac

PACKAGES: RIASSUNTO I packages: permettono di creare gruppi di classi e interfacce fra loro in relazione definiscono uno spazio di nomi locale per classi e interfacce evitando conflitti con classi e inter-facce di altri packages permettono di avere classi, interfacce e membri (campi e metodi) non visibili all’esterno del package possono essere organizzati gerarchicamente

UNITA’ DI COMPILAZIONE: RIASSUNTO MyClass.java package Roberto.util; /* opzionale */ import java.util.* ; /* opzionale */ public class MyClass { … } class MyOtherClass { /* opzionale */ interface MyInterface { /* opzionale */

STRUTTURA DI UN’APPLICAZIONE

STRUTTURA DI UN’APPLICAZIONE Affinchè un sistema a oggetti “parta”, devo avere una classe con un metodo statico e pubblico di nome main a b c d g f e main

HALLO WORLD class Hello { public static void main (String args []) { Hello.java class Hello { public static void main (String args []) { System.out.println("Hello World!"); } obbligatorio in questa forma

SPIEGAZIONI public static void main (String args []) void indica che main non ritorna nulla, il che è necessario per superare il type-checking del compilatore args[] sono gli argomenti passati a main dalla shell quando si digita: java Hello arg1 arg2 ... argn String dice che gli argomenti sono di classe String public rende il metodo main visibile alle altre classi - e al comando java (interprete) static associa main alla classe Hello, e non alle sue istanze System.out.println("HelloWorld!") invoca il metodo println dell’oggetto out della classe System, che stampa la stringa sul file stdout

UNITA’ DI COMPILAZIONE Il sorgente di un’applicazione consiste di uno o più file (“unità di compilazione”) Ogni file contiene una o più dichiarazioni di classi (o di interfacce), di cui al più una dichiarata public Il nome del file deve essere uguale a quello della sua classe public , con estensione .java: public class a {... class b {... class c {.. file a.java stesso nome

COMPILAZIONE ED ESECUZIONE <bytecode> javac a.java public class a {… public main (..) {…. a.java a.class java a args class b {… …uso di c... b.class il compilatore crea file di nome classname.class classe c, usata da b, compilata in precedenza La classe a deve contenere un metodo pubblico e statico di nome main c.class

COMPILAZIONE ED ESECUZIONE Verificare le caratteristiche del sistema di programmazione utilizzato

MULTITHREADING

CHE COS’E’ IL MULTITHREADING possibilità di realizzare più flussi di controllo concorrenti (“threads”) nell’ambito di una stessa applicazione possibilità di condividere dati fra i threads possibilità di controllare i threads e di sincroniz-zare i threads fra loro, attraverso opportune primitive Nota: la filosofia è ispirata ai monitor di C.A.R. Hoare

MULTITASKING E MULTITHREADING OS Task 1 Task 2 Task 3 Memoria locale Memoria condivisa OS Task 1 Task 2 Memoria locale Memoria condivisa Monitor (interprete Java) Thread 1 Thread 2 Thread 3

RUN-TIME DATA AREA …. variabili locali, ecc. dei metodi Stack Method Area Heap Program Counter …. Thread 1 Thread 2 Thread n oggetti condivisi fra i thread, creati dinamicamente e garbage collected qui vengono caricati dal class loader i files .class, contenenti la descrizione della classe (campi, metodi, ecc.) variabili locali, ecc. dei metodi

LA CLASSE Thread In Java, ogni thread è un oggetto: ogni singolo thread viene creato come una istanza della classe java.lang.Thread ogni istanza di java.lang.Thread deve essere associata a un metodo run() di qualche classe, che contiene il codice che deve essere eseguito dal thread la classe java.lang.Thread contiene tutti i metodi per la gestione dei thread … e in particolare il metodo start(), per “lanciare” il thread con il metodo run() “opportuno”

LA CLASSE Thread: SCHEMA “lancia” il thread, rendendolo schedula- bile. Esegue il metodo run() del Thread, che a sua volta lancia il metodo run() dell’oggetto passato come parametro al costruttore Thread(), oppure (se Thread non ha parametri) non fa nulla. public class Thread implements Runnable Runnable target; …. public syncronized native void start() { … run(); } public void run() { if (target != null) { target.run(); } } Thread (Runnable t) { target = t; …. } public interface Runnable { public abstract void run();

COME REALIZZARE UN THREAD Ci sono due metodi per realizzare un thread: Metodo 1: implementando la interfaccia Runnable Metodo 2: estendendo la classe java.lang.Thread e sovrascrivendo run()

METODO 1 public interface Runnable { public abstract void run(); } class Application implements Runnable { public void run() { <body> } ... Application a = new Application(); /* creo l’Application a il cui metodo run() dovrà essere eseguita in un thread */ Thread th = new Thread(a); /* creo un thread e gli passo il riferimento all’Application a */ th.start(); /* lancio il thread, eseguendo il metodo a.run() */

In questo esempio, un main crea e lancia i thread public class drinks { public static void main(String[] a) { Coffee c = new Coffee(); Tea t = new Tea(); Thread th1 = new Thread(c) ; th1.start(); Thread th2 = new Thread(t) ; th2.start() ; } class Coffee implements Runnable { public void run() { while(true) { System.out.println(“I like coffee”);} class Tea implements Runnable { while(true) { System.out.println(“I like tea”);}

ESEMPIO 1.2 In questo esempio, ogni oggetto crea e lancia il proprio thread public class drinks { public static void main(String[] a) { Coffee c = new Coffee(); Tea t = new Tea() ; } class Coffee implements Runnable { Thread th; public void run() { while(true) { System.out.println(“I like coffee”);} Coffee() { th = new Thread(this) ; th.start(); } class Tea implements Runnable { while(true) { System.out.println(“I like tea”);} Tea() { th = new Thread(this) ; th.start() ; }

METODO 2 class Thread implements Runnable { public void start() { … run(); } public void run() { } class MyThread extends Thread { // eredita start() public void run() { < body> } MyThread p = new MyThread(); p.start(); sovrascrive

In questo esempio, un main crea e lancia i thread public class drinks { public static void main(String[] a) { Coffee th1=new Coffee(); th1.start(); Tea th2=new Tea() ; th2.start(); } class Coffee extends Thread { public void run() { while(true) { System.out.println(“I like coffee”);} class Tea extends Thread { while(true) { System.out.println(“I like tea”);}

ESEMPIO 2.2 In questo esempio, ogni thread si lancia da solo public class drinks { public static void main(String[] a) { Coffee th1=new Coffee(); Tea=th2 new Tea() ; } class Coffee extends Thread { public void run() { while(true) { System.out.println(“I like coffee”);} Coffee() { start(); } class Tea extends Thread { while(true) { System.out.println(“I like tea”);} Tea() { start(); }

QUANDO UN thread TERMINA? Un thread continua nella sua esecuzione, fino a quando: 1. run() ritorna 2. viene eseguito il metodo stop() del thread 3. una eccezione causa l’uscita da run()

SCHEDULING lo scheduling è effettuato sulla base della priorità dei thread la priorità può essere modificata mediante il metodo setPriority a parità di priorità, lo scheduling è di tipo round-robin

ALCUNI METODI DI Thread public void start() lancia il thread public void run() esegue il codice public final void stop() distrugge il thread public final void suspend() sospende il thread public final void resume() riattiva il thread public static void sleep(long n) sospende il thread per n msec public final void setPriority(int newPriority) modifica la priorità public final int getPriority() ottieni la priorità public static void yield() rischedula public final native boolean isAlive() true se il thread è vivo ...

GLI STATI DI UN THREAD Alive New thread Runnable Not Runnable Dead yield() new Thread() suspend() sleep() wait() New thread Runnable Not Runnable start() resume() notify() stop() run() exit stop() stop() Dead

IL PROBLEMA DELLA MUTUA ESCLUSIONE thread 1 thread 2 class Count { int i = 0; void incr() { i+1 1 i = i + 1; i -1 -1 } i = 1 void decr() { i = -1 i = i - 1; } Il valore finale di i dipende dalla sequenza di esecuzione

METODI synchronized Il modificatore synchronized prescrive che il metodo a cui si applica sia eseguito da un solo thread alla volta: - quando un thread esegue un metodo synchronized, viene fatto un lock dell’oggetto cui appartiene il metodo (o, per metodi static, della classe) - quando il thread termina l’esecuzione del metodo, viene fatta una unlock - prima di tale unlock, eventuali altri metodi synchronized si pongono in attesa

ESEMPIO thread 1 thread 2 lock istanza di a call metodo synchronized

ESEMPIO thread 1 thread 2 istanza di a lock istanza di a call metodo synchronized lock call metodo synchronized istanza di a

ESEMPIO thread 1 thread 2 istanza di a lock istanza di a classe a call metodo synchronized lock call metodo synchronized istanza di a call metodo static synchronized classe a

ESEMPIO i=0 thread 1 thread 2 class Count { int i = 0; synchronized void incr() { i+1 1 i = i + 1; i = 1 } synchronized void decr() { i -1 0 i = i - 1; i = 0 Il valore finale di i NON dipende dalla sequenza di esecuzione

synchronized ( myObject ) { <blocco> } BLOCCHI synchronized La keyword synchronized può essere usata anche per proteggere blocchi arbitrari, e non solo metodi in tal caso, occorre specificare l’oggetto di cui acquisire il lock Esempio: synchronized ( myObject ) { <blocco> }

ESEMPIO synchronized void MyMethod() { … } è equivalente a: synchronized (this) {

ESEMPIO import java.util.Vector; public class MsgQueue { Vector queue = new Vector(); public synchronized void send(Object obj) { queue.addElement(obj); } public synchronized Object receive() { if (queue.size() == 0) return null; Object obj = queue.firstElement(); queue.removeElementAt(0); return obj;

wait, notify Sono metodi della classe Object: public final void wait(); /* rilascia il lock e si pone in wait */ public final void wait(long millis); /* wait con timeout */ public final void notify(); /* rilascia il lock */

ESEMPIO Schema Produttore-Consumatore // Thread produttore: produce un dato while (buffer_full) wait() produce_data() notify() // Thread consumatore: consuma un dato while (no_data) wait() consume_the_data()