CORSO DI SISTEMI OPERATIVI Università di Milano, a.a

Presentazione sul tema: "CORSO DI SISTEMI OPERATIVI Università di Milano, a.a"— Transcript della presentazione:

1 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)

2 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 …..

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

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

5 CARATTERISTICHE

6 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)

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

8 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++--==)

9 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

10 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

11 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

12 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 ……. …….

13 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

14 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”

15 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

16 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)

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

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

19 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

20 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

21 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

22 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

23 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)

24 JAVA E INTERNET

25 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

26 URL: Uniform Resource Locator
<protocollo> :// <nome del server> <nome del file> Esempio: deve essere risolto in un indirizzo internet (IP) con l’aiuto di un Domain Name Server (DNS)

27 HTML: ESEMPIO <HTML> <HEAD>
<TITLE> Esempio </TITLE> Esempio </HEAD> Testo <BODY> DSI <P> Testo <A HREF=“ DSI </A> </BODY> </HTML>

28 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

29 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

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

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

32 PROGRAMMAZIONE A OGGETTI
PARTE 2 PROGRAMMAZIONE A OGGETTI

33 PARADIGMI DI PROGRAMMAZIONE

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

35 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”)

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

37 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 ….

38 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

39 SPAGHETTI E STRUTTURA

40 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”

41 IL MODELLO PROCEDURALE: LINGUAGGI
Fortran Cobol Basic Pascal 1972 C

42 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

43 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

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

45 IL PARADIGMA A OGGETTI

46 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]

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

48 “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)

49 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

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

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

52 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")

53 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

54 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

55 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à

56 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")

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

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

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

60 ESEMPIO: ARTIFICIAL LIFE

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

62 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

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

64 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"

65 GERARCHIA DI CLASSI Generalizzazione Specializzazione instanziazione

66 ESEMPIO obiect Veicolo VeicoloSenza Motore Veicolo A Motore
Motocicletta Automobile Taxi

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

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

69 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

70 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

71 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

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

73 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

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

75 PARTE 3 IL LINGUAGGIO JAVA

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

77 CARATTERISTICHE LESSICALI

78 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 ( 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)

79 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

80 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)

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

82 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

83 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)

84 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

85 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

86 TIPI

87 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

88 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

89 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

90 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

91 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);

92 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

93 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

94 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

95 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

96 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

97 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

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

99 STRUTTURE DI CONTROLLO

100 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!

101 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 );

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

103 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 */ }

104 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

105 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

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

107 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

108 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

109 CLASSI

110 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

111 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 */

112 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

113 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)

114 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

115 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;

116 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 = e combinazione */ … MySafe.SerialNumber …. Il costruttore Safe fa sì che ogni istanza di Safe abbia un SerialNumber unico

117 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 */

118 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

119 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

120 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

121 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

122 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 */

123 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;

124 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

125 EREDITARIETA’

126 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

127 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”

128 “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; … } }

129 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

130 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)

131 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;

132 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 */

133 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> }

134 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

135 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)

136 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 !

137 INTERFACCE

138 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); }

139 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

140 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 */

141 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() { … } …

142 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

143 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

144 PACKAGES

145 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

146 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

147 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

148 PACKAGES STANDARD

149 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 {..

150 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

151 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

152 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

153 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

154 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

155 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 {...

156 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

157 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

158 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

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

160 STRUTTURA DI UN’APPLICAZIONE

161 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

162 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

163 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

164 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

165 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

166 COMPILAZIONE ED ESECUZIONE
Verificare le caratteristiche del sistema di programmazione utilizzato

167 MULTITHREADING

168 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

169 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

170 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

171 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”

172 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();

173 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()

174 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() */

175 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”);}

176 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() ; }

177 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

178 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”);}

179 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(); }

180 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()

181 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

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

183 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

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

185 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

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

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

188 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

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

190 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> }

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

192 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;

193 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 */

194 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()