Intelligenza Artificiale
Breve introduzione a Java
(ed alla rappresentazione
ad oggetti)
Marco Piastra
Breve introduzione a Java - 2
Argomenti
1.
Modello astratto e modello implementativo
nei linguaggi di programmazione
2.
Modello astratto: rappresentazione ad oggetti
3.
Modello implementativo: macchina virtuale
4.
Aspetti particolari:
- gestione implicita della memoria (garbage collection);
- multithreading;
- programmazione distribuita.
Marco Piastra
Breve introduzione a Java - 3
1
Modello astratto e modello
implementativo
nei linguaggi di programmazione
Marco Piastra
Breve introduzione a Java - 4
Il progetto di un linguaggio
Da tener presente:
• un ‘linguaggio di programmazione’ è progettato
in riferimento ad modello implementativo
specifico;
• il progetto del linguaggio include un rilevante
aspetto teorico, cioè un modello astratto (e.g. il
concetto di variabile);
• i due aspetti sono strettamente correlati.
Marco Piastra
Breve introduzione a Java - 5
Il progetto di un linguaggio (2)
• Scelta di un modello astratto:
– entità di base della programmazione (e.g. variabili globali,
variabili locali, array, puntatori, funzioni).
– modo di descrivere i programmi
(e. g. programmazione strutturata);
– linguaggio (inteso come unione di una sintassi ed una
semantica formale);
• Scelta di un modello implementativo:
– tecniche di compilazione (e.g. compilazione parziale) e di
linking;
– esecuzione a run-time (e.g. gestione della memoria, gestione
dello stack delle chiamate);
– possibilità di estensione (librerie specifiche).
Marco Piastra
Breve introduzione a Java - 6
Origini di Java e C (e C++)
• I due linguaggi hanno origini diverse
• Il C (ed il C++) derivano dagli studi sui linguaggi
per la realizzazione di sistemi operativi (e.g. Unix)
e software di base (e.g. database server)
• Java deriva (in gran parte) dai linguaggi
sviluppati per l’intelligenza artificiale
• Infatti, ad esempio:
– anche se la sintassi assomiglia a quella del C++;
– il modello ad oggetti e l’idea della macchina virtuale e del
bytecode provengono dallo Smalltalk-80;
– l’idea dei package proviene dal Common Lisp.
Marco Piastra
Breve introduzione a Java - 7
Creare un programma in C
Codice sorgente
#include <stdio.h>
...
main(int argc, char **argv) {
...
initialize(argv[0]);
run(argv[1], argv[2]);
if (!errno)
printf(”Done.\n”);
else
exit(errno);
}
cc <opzioni> <nomi di file>
Compilatore
Binario
Binario
Programma
eseguibile
Linker
Librerie
Librerie
Librerie
• Tipicamente:
–
–
–
–
si creano uno o più moduli (file) di codice sorgente;
si utilizzano librerie standard e/o librerie specifiche;
il compilatore traduce il codice sorgente in un formato binario;
il linker combina il prodotto della compilazione con le librerie.
Marco Piastra
Breve introduzione a Java - 8
Un interprete di programmi
Codice sorgente
;; File fattoriale.lisp
Interprete Common Lisp
Listener
(defun fattoriale (par)
(if (eq par 0)
;; then
(return 0)
;; else
(return
(* par
(fattoriale
(- par 1)))))
)
Lisp> (load “fattoriale.lisp”)
Done.
Lisp> (fattoriale 2)
2
Loader
Binario
Binario
Linker
Librerie
Librerie
Librerie
• Tipicamente:
–
–
–
–
non si produce un programma eseguibile indipendente;
il codice sorgente viene tradotto in un formato binario;
il collegamento tra ‘pezzi’ di programma viene fatto ‘al volo’;
le operazioni effettive vengono eseguite dall’interprete.
Marco Piastra
Breve introduzione a Java - 9
Differenze di paradigma
• In C:
– la sintassi è concepita per favorire i controlli di correttezza;
– le entità principali sono statiche (e.g. variabili globali, array,
funzioni) e si usano tecniche esplicite per la gestione della
memoria dinamica (i.e. malloc e free);
– un programma compilato ed eseguibile è di fatto immutabile.
• In un linguaggio interpretato (e.g. Common Lisp):
– la sintassi è concepita per facilitare la scrittura dl codice;
– le entità principali sono dinamiche, e.g. liste di elementi;
– la composizione di un programma è definita dallo stato
dell’interprete al momento dell’esecuzione.
Marco Piastra
Breve introduzione a Java - 10
2
Il modello astratto di Java:
rappresentazione ad oggetti
Marco Piastra
Breve introduzione a Java - 11
Un modello ad oggetti
• L’idea informale:
rappresentare le entità della programmazione
come aggregazioni di variabili e metodi
Esempio:
comportamento
struttura
variabili
ContoCorrente
saldoAttuale
deposita
codice
ritira
titolare
saldo
interesse
fido
modificaFido
modificaInteresse
metodi
• Agli inizi, qualcuno ha suggerito l’idea di
circuiti integrati software
Marco Piastra
Breve introduzione a Java - 12
Scambio di messaggi
• Il flusso dell’esecuzione viene visto come
un flusso di messaggi
Oggetto A
Ciclista
ricevente.nomeMetodo(parametri)
Oggetto B
Esempio:
bici.cambiaRapporto(2)
bici
Bicicletta
messaggio
• Componenti di un messaggio:
– un riferimento al ricevente;
– il nome del metodo;
– i parametri.
Marco Piastra
Breve introduzione a Java - 13
Classi
• Descrivere gli oggetti uno ad uno è poco
vantaggioso. Infatti:
– ogni oggetto richiederebbe una descrizione specifica;
– la grande varietà ostacolerebbe la comunicazione.
• Al contrario, una classe è uno schema generale
per la creazione di oggetti simili:
– la struttura degli oggetti è descritta come schema;
– il comportamento degli oggetti è definito in modo effettivo.
comportamento
struttura
dichiarazione delle variabili
metodi effettivi
Marco Piastra
Breve introduzione a Java - 14
Classi e istanze: ContoCorrente
class ContoCorrente {
String codice;
String titolare;
float saldo;
...
void deposita(float somma) {
saldo += somma;
}
void preleva(float somma) {
saldo -= somma;
}
ContoCorrente
ritira
codice
titolare
saldo
istanza di
deposita
N58AB
Gino
1.350
istanza di
}
c1.deposita(31)
istanza di
N58AB
Lino
2.500
AA54Z
Pino
7.823
c2.preleva(275)
c3.deposita(50)
Operatore
Marco Piastra
Breve introduzione a Java - 15
Ereditarietà
• L’idea di base è quella di classificare gli oggetti
mettendo a fattor comune le analogie
Animale
Vertebrato
Pesce
Invertebrato
Anfibio Rettile Uccello Mammifero
Carnivoro
Erbivoro
• Attenzione: la gerarchia dipende dallo scopo
Marco Piastra
Breve introduzione a Java - 16
Ereditarietà in Java
• Le sottoclassi ereditano la struttura (intesa come
schema) ed il comportamento dalle superclassi
Alfa
method1
class Alfa {
String var1;
}
void method1() {
...
}
var1
Beta
class Beta extends Alfa {
String var2;
}
void method2() {
...
}
method1
var1
var2
method2
class Gamma extends Beta {
String var3;
}
void method3() {
...
}
Gamma
method1
var1
var2
var3
method2
method3
Marco Piastra
Breve introduzione a Java - 17
Struttura di classi
• Un programma Java è rappresentato da una
gerarchia di classi
• La classe Object è la radice di tale gerarchia
class A1 {
...
}
Specializzazione
A1
A2
class A2 extends A1{
...
}
B1
B2
C1
B3
B4
B5
Marco Piastra
Generalità
Object
Breve introduzione a Java - 18
Uso di una struttura di classi
• Per classificare, ovvero strutturare le differenze
– nella pratica, si usa raramente
Bicicletta
Bicicletta Multirapporto
Bicicletta da Strada
Bicicletta Elettrica
Mountain Bike
• Per fattorizzare, ovvero per scrivere meno codice
ContoCorrente
ContoManager
ritira deposita
codice
titolare
saldo
calcolaInteresse
ContoIO
ContoFamiglia
Marco Piastra
Breve introduzione a Java - 19
Uso di una struttura di classi
• Per disaccoppiare aspetti diversi di uno stesso
programma
– e rendere lo stesso programma più facile da estendere
Un ipotetico sistema di trasmissione
usa solo questo livello
della gerarchia ...
Oggetto Trasmissibile
inserisci
contenuto
estrai
Testo
Immagine
Video
... mentre le specializzazioni ulteriori
sono pertinenti in altre parti del programma
– a questo scopo si usano spesso anche le interfacce
Marco Piastra
Breve introduzione a Java - 20
Oscuramento dei metodi
• (Detto anche overriding)
• In una sottoclasse si può oscurare un metodo
definito in una superclasse con una nuova
definizione.
class Bicicletta {
...
void cambiaRapporto(int r) {
...
}
}
Ciclista
bici.cambiaRapporto(2)
bici
Bicicletta
class MountainBike extends Bicicletta {
...
void cambiaRapporto(int r) {
...
}
}
• La compatibilità con la segnatura definita nella
superclasse viene preservata (polimorfismo)
Marco Piastra
Breve introduzione a Java - 21
Specializzazione dei metodi
• (Detta anche overloading)
• La ‘risposta’ di un oggetto ad un messaggio può
dipendere dal tipo dei parametri
class Zoofilo extends Persona {
...
void accarezza(Gattino g) {
}
void accarezza(Tigre t) {
}
Spiritoso
affettuosamente
amico.accarezza(animaleSconosciuto)
amico
Zoofilo
col pensiero
void accarezza(Object o) {
}
informati prima
}
• La selezione è automatica in base alla segnatura
Marco Piastra
Breve introduzione a Java - 22
Tipo delle variabili
• In Java ogni variabile deve avere un tipo
dichiarato
• In prima approssimazione, vi sono due categorie
di tipi:
– tipi primitivi: int, float, byte short, long, double, char,
boolean);
– riferimenti ad oggetti (i.e. Object o sottoclasse).
class Ciclista extends Persona {
valore
int mediaKmAlGiorno;
Bicicletta bici;
...
riferimento
void allenamento() {
int rapporto;
...
bici.cambiaRapporto(rapporto);
}
“Romano Prodi”
70
riferimento
Bicicletta
}
Marco Piastra
Breve introduzione a Java - 23
Come si scrive un metodo
• In prima approssimazione, un metodo Java è
molto simile ad una funzione C:
– dichiarazione formale: nome del metodo, tipo di valore
ritornato, nome e tipo dei parametri formali;
– gli operatori sono quelli del C (e.g. +, *, =, +=, ==, !=, ...);
– le istruzioni di controllo sono quelle del C (i.e., if, else,
switch, for, while, do);
– l’istruzione di ritorno è return.
class Aritmetica {
long fattoriale(long arg) {
if (arg == 0) {
return 1L;
}
else {
long temp;
}
}
}
temp = arg * this.fattoriale(arg - 1);
return temp;
Marco Piastra
Breve introduzione a Java - 24
Classi come oggetti
• In Java anche le classi sono oggetti
• Quindi anche le classi:
– rispondono ai messaggi;
– hanno variabili (di classe);
– hanno metodi (di classe).
• Per definire le entità di classe si usa la parola
chiave static
Aritmetica
Aritmetica.fattoriale(33)
class Aritmetica {
static float piGreco = 3.141592;
}
static long fattoriale(long arg) {
...
}
fattoriale
3.141592
• Alle classi si può fare riferimento per nome
Marco Piastra
Breve introduzione a Java - 25
Nota: per chi conosce il C++
• In C++ si usa la parola chiave static con lo stesso
significato
• Ma in C++, le classi non sono oggetti ma solo
dichiarazioni a beneficio del compilatore
• Conseguenza notevole: in Java si può determinare a
run-time la classe di un oggetto, in C++ no.
class Zoofilo extends Persona {
...
void accarezza(Object obj) {
if (obj instanceof Serpente) {
no grazie
}
else if (obj instanceof Pesciolino) {
volentieri, ma come?
}
}
...
ContoCorrente
obj.getClass()
codice
istanza di
N58AB
}
Marco Piastra
Breve introduzione a Java - 26
Protezioni
• L’accesso alle entità di classe o di istanza può essere
protetto
• In Java vi sono quattro livelli di protezione e tre
parole chiave:
–
–
–
–
public
protected
package
private
accesso senza restrizioni
solo nello stesso package o nelle sottoclassi
solo nello stesso package
solo nella classe
class ContoCorrente {
private float saldo;
...
float saldo(Persona richiedente) {
if (richiedente.autorizzato())
return saldo;
else
nega informazione
}
}
class MountainBike
extends Bicicletta {
void cambiaRapporto(int r) {
attivaProtezione();
super.cambiaRapporto();
disattivaProtezione();
}
private void attivaProtezione() {...}
}
private void disattivaProtezione() {...}
Marco Piastra
Breve introduzione a Java - 27
Protezioni: esempio
class Automobile {
// attributi di classe
static int numeroDiRuote = 4;
static public boolean haTarga = true;
static private Vector archivio;
// attributi di istanza
public String marca;
public String colore;
public int annoDiImmatricolazione;
public String targa;
public int numero DiCavalli;
protected Persona titolare;
private int rapporto;
// metodi di classe
static protected void inserisciInArchivioAutoveicoli(Automobile a) {
archivio.addElement(a);
}
...
// metodi di istanza
public void cambiaRapporto(int r) {
...
rapporto = r;
}
public int rapporto() {
return rapporto;
}....
...
}
Marco Piastra
Breve introduzione a Java - 28
Costruttori
• Un oggetto Java viene sempre creato tramite un
metodo speciale detto costruttore
• Ogni classe ha uno o piu` costruttori
• Valgono i principi di ereditarieta`, di
specializzazione e di oscuramento
class ContoCorrente {
ContoCorrente() {
generico
}
class ContoAziendale
extends ContoCorrente {
ContoAziendale() {
// Oscuramento
generico
}
ContoCorrente(Persona richiedente) {
intestato
}
}
ContoAziendale(Azienda richiedente) {
// Specializzazione
intestato
}
}
Marco Piastra
Breve introduzione a Java - 29
Pseudo-variabili
• Nei metodi di istanza, è possibile utilizzare le
pseudo-variabili this e super
• this fa riferimento all’istanza stessa
– si usa per evitare ambiguità
class Ciclista extends Persona {
Bicicletta bici;
boolean dimmiSeTua(Bicicletta bici) {
return this.bici = bici;
}
}
• super fa riferimento all’istanza stessa come se
appartenesse alla superclasse
– si usa per evitare ambiguità e per specializzare metodi
class ContoCorrente {
float saldo;
class ContoAziendale {
RegistroCassa registro;
void deposita(float somma) {
saldo += somma;
}
void deposita(float somma) {
super.deposita(somma);
registro.annotaEntrata(somma);
}
}
}
Marco Piastra
Breve introduzione a Java - 30
Interfacce
• L’idea di base è quella di un contratto tra oggetti,
una sorta di visibilità limitata
Fisco
contribuente.dichiaraImponibile(1998)
Persona
interfaccia Contribuente
interface Contribuente {
float dichiaraImponibile(int anno);
}
class Ingegnere extends Persona
implements Contribuente {
...
float dichiaraImponibile(int anno) {
...
}
}
Marco Piastra
Breve introduzione a Java - 31
Uso delle interfacce
• Le interfacce contengono solo:
– la dichiarazione di metodi (come signature);
– la definizione di costanti
• Le interfacce sono un tipo valido per le variabili
• Le interfacce possono essere organizzate in
strutture ad eredità multipla
• Una classe può implementare un numero
qualsiasi di interfacce
class Ingegnere extends Persona
implements Contribuente,
MembroOrdineIngegneri,
PersonaTipicamenteNoiosa,
... {
...
}
Marco Piastra
Breve introduzione a Java - 32
Tipi in Java
• I tipi di dati in Java sono organizzati in quattro
categorie:
– tipi primitivi (char, boolean, byte, int, long, short,
float, double)
– le classi (i.e. Object e tutte le sue sottoclassi)
– le interfacce
– gli array (dei tre tipi precedenti)
• Non esistono invece i tipi:
– puntatori
– funzioni
Marco Piastra
Breve introduzione a Java - 33
Gestione delle eccezioni
• La gestione delle eccezioni in Java è un sistema
per governare il flusso dell’esecuzione a seguito
di errori
– di fatto, sostituisce l’unico uso sensato della goto
– (che in Java non esiste)
class Spiritoso extends Persona {
...
void proponi(Zoofilo amico) {
try {
amico.accarezza(...);
}
catch (MaTuSeiMattoException e) {
// Evidentemente, non gradisce
}
...
}
class Zoofilo extends Persona {
...
void accarezza(Object obj) {
if (obj instanceof ScorpioneVelenoso) {
}
}
throw new MaTuSeiMattoException();
...
}
}
Marco Piastra
Breve introduzione a Java - 34
Eccezioni
• Le eccezioni sono organizzate come una
gerarchia di classi;
• L’abbinamento throw / catch si stabilisce in
base al tipo;
• Esistono eccezioni checked (i.e. che vengono
controllate dal compilatore) ed eccezioni
uncheked.
Throwable
class Zoofilo extends Persona {
...
void accarezza(Object obj)
throws MaTuSeiMattoException {
if (obj instanceof ScorpioneVelenoso) {
Exception
RuntimeException
}
}
MaTuSeiMattoException
throw new MaTuSeiMattoException();
...
}
Marco Piastra
Breve introduzione a Java - 35
3
Il modello implementativo di Java:
macchina virtuale
Marco Piastra
Breve introduzione a Java - 36
Modello implementativo
• Le classi compilate in bytecode sono portabili su
qualsiasi macchina per cui esista una macchina
virtuale Java
• Il programma finale viene assemblato a run-time
(i.e. linking tra le classi) e dipende quindi
dall’ambiente di esecuzione
• Quindi:
– si possono costruire programmi indipendenti dalla piattaforma
hardware e software (purchè esista una macchina virtuale)
– le classi compilate in bytecode assomigliano a componenti
software ricombinabili a piacere
Marco Piastra
Breve introduzione a Java - 37
Bytecode
• non è un codice direttamente eseguibile
• ma è un codice (binario) per una macchina
virtuale (cioè un interprete) che si incarica della
esecuzione effettiva
Classe in bytecode
java
Macchina
virtuale
Macchina reale (e.g. PC Intel con Linux)
Marco Piastra
Breve introduzione a Java - 38
Bytecode (2)
metodo in Java
...
void spin() {
int i;
for (i = 0; i < 100; i++) {
// Loop body is empty
}
}
...
bytecode compilato
(in forma simbolica)
...
0
1
2
5
8
9
11
14
iconst_0
istore_1
goto 8
iinc 1 1
iload_1
bipush 100
if_icmplt 5
return
//
//
//
//
//
//
//
//
Push int constant 0
Store into local variable 1 (i=0)
First time through don't increment
Increment local variable 1 by 1 (i++)
Push local variable 1 (i)
Push int constant 100
Compare and loop if less than (i < 100)
Return void when done
...
Marco Piastra
Breve introduzione a Java - 39
Compilazione
• In Java la compilazione è:
– parziale (ciascuna classe viene compilata separatamente)
– con verifica (di correttezza sintattica e di tipo)
File “Alfa.java”
javac <opzioni> Alfa.java
class Alfa {
String var1;
}
Compilatore
void method1() {
...
}
Classe in bytecode
File “Alfa.class”
Verifica
CLASSPATH
Classe in bytecode
Librerie
Librerie
Altre classi
compilate
Marco Piastra
Breve introduzione a Java - 40
Programma
• Un programma Java è un insieme di classi
• Generalmente tale insieme è chiuso, ma è
potenzialmente aperto
• La composizione di questo insieme è stabilita
dalla macchina virtuale a run-time
java nomeClasse
CLASSPATH
Classe in bytecode
Classe in bytecode
Macchina
virtuale
ClassLoader
Classe in bytecode
CLASSPATH
Marco Piastra
Breve introduzione a Java - 41
Bootstrap dell’esecuzione
• La macchina virtuale Java esegue come prima
cosa il metodo main della classe di bootstrap
java Copia DaUnFile.txt AUnAltroFile.txt
class Copia {
...
static void main(String[] args) {
if (args.length < 2) {
System.out.println(
”Uso: Copia <from> <to>”
System.exit(0);
}
else {
copia(args[0], args[1]);
}
...
}
Copia.class
CLASSPATH
Copia.class
Macchina
virtuale
Marco Piastra
Breve introduzione a Java - 42
Package
• L’idea originale (Common Lisp) è quella di un
sistema per organizzare i simboli
• nomi comuni come ad esempio “Persona” sono
facilmente usati in più programmi
• i package possone essere utilizzati per
contestualizzare il nome di una classe o interfaccia
package it.unipv;
Persona
package it.ministeroDelleFinanze;
package it.unipv.admin;
Dipendente
Studente
Persona
Contribuente
Marco Piastra
Breve introduzione a Java - 43
Package (2)
• L’idea originale (Common Lisp) è di un sistema di
organizzazione dei simboli:
– si usa quindi una notazione qualificata composta da un
prefisso e da un simbolo
esempio: it.unipv.Persona
– la pseudo-istruzione package definisce il package di
riferimento
– la pseudo-istruzione import serve ad abbreviare i riferimenti
simbolici
package it.unipv.esercitazioniAI;
import it.unipv.Persona;
class StudenteDelCorsoAI extends Persona {
...
}
Marco Piastra
Breve introduzione a Java - 44
Packages & directories
• In Java il sistema dei package è anche un modo
per organizzare le classi (sia .java che .class):
– la struttura del prefisso viene trasformata in percorso
nel file system :
it.unipv.Persona
diventa
$CLASSPATH/it/unipv/Persona (.java o .class)
– i classloader della macchina virtuale (i.e. java) e del
compilatore (i.e javac) usano le stesse convenzioni.
Marco Piastra
Breve introduzione a Java - 45
4
Altri aspetti particolari di Java:
garbage collection, multithreading,
programmazione distribuita
Marco Piastra
Breve introduzione a Java - 46
Allocazione dinamica
della memoria
• In C la memoria dinamica deve essere gestita
in modo esplicito
• Errori comuni:
– mancata allocazione
– mancata deallocazione
• In C++ gli oggetti sono allocati
dinamicamente
• In C++ esistono delle entità standard per
facilitare la gestione (costruttori, distruttori)
Marco Piastra
Breve introduzione a Java - 47
Allocazione dinamica in Java
• In Java tutte le entità sono allocate
dinamicamente (e.g. non esistono variabili
globali)
• Tuttavia, solo l’allocazione della memoria
(intesa come creazione di oggetti) è gestita
esplicitamente
• La deallocazione è gestita dalla macchina
virtuale (garbage collection)
Marco Piastra
Breve introduzione a Java - 48
Mark and Sweep
• Un algoritmo di garbage collection che prevede
l’interruzione dell’esecuzione
• Si usa quando gli oggetti sono molti e
globalmente accessibili
Obj054A
Obj0F32
Mark
Sweep
Obj0B60
Obj0B60
Obj0B60
Obj0102
Obj0B60
Obj0102
Obj01F5
Obj0740
Obj0987
Obj01C3
Obj0E4F
Obj0987
Obj01C3
Marco Piastra
Breve introduzione a Java - 49
Mark and Sweep (2)
• Il principale punto di partenza per la fase di mark
è lo stack
Test04
Stack (stadio n)
class Test {
Test04.t(0)
null
Test03.t(1)
Test t
Test02.t(2)
Test t
Test01.t(3)
Test t
GCTest.main
Test t
Test03
Test02
Test01
static void main(String[] args) {
Test t = new Test();
}
t.test(3);
void test(int n) {
if (n == 0) return;
Test t = new Test();
t.test(n - 1);
}
}
Test04
Test03
Test02
Stack (stadio n + 4)
GCTest.main
Test01
Test t
Marco Piastra
Breve introduzione a Java - 50
Reference Counting
• Un algoritmo di garbage collection che non
prevede l’interruzione dell’esecuzione
• Si usa quando gli oggetti sono pochi e/o non
raggiungibili globalmente (e.g. sistema distribuito)
Obj054A(1)
Obj0F32(0)
Reference Counting
Obj0B60(2)
Obj0102(1)
Obj0B60(1)
Obj01F5(1)
Obj0987(1)
Obj01C3(1)
Obj0740(1)
Obj0E4F(1)
Marco Piastra
Breve introduzione a Java - 51
Multithreading
• Un thread è un flusso di controllo sequenziale in
un programma
– un thread viene talvolta anche chiamato lightweight process
• Ogni thread possiede delle risorse private (e.g.
stack e pc) ...
• ... tuttavia i thread di un programma condividono
lo stesso spazio di indirizzamento
Thread1
Thread2
Obj0987
Obj01C3
Obj0B60
Processo
Marco Piastra
Breve introduzione a Java - 52
Sincronizzazione
• Il multithreading non è utilizzabile in pratica
senza la possibilità di sincronizzare i thread
• In Java ciascun oggetto può comportarsi come
un monitor:
– un monitor è un insieme di procedure relative ad una singola
entità (i.e. un oggetto Java);
– un monitor implementa il principio di mutua esclusione: solo
un thread alla volta può eseguire una procedura.
deposita(x)
T
ContoCorrente
T
T
coda di attesa
preleva(y)
Marco Piastra
Breve introduzione a Java - 53
Interfacce remote
• Il principio di base è quello di inviare messaggi a
distanza
Macchina Virtuale
ricevente.nomeMetodo(parametri)
cliente
servente
interfaccia
(funzioni)
Macchina Virtuale B
cliente
Macchina Virtuale A
proxy
ricevente.nomeMetodo(parametri)
servente
(rete)
interfaccia
(funzioni)
Marco Piastra
Breve introduzione a Java - 54
Proxy & Skeleton
• L’effetto viene ottenuto usando due componenti
software (solitamente generate
automaticamente):
– che simulano la presenza del servente in B
– e trasmettono le chiamate remote in A
Macchina Virtuale B
proxy
stub
cliente
Macchina Virtuale A
skeleton
servizio
descrizione IDL
interfaccia
(funzioni)
Marco Piastra
Breve introduzione a Java - 55
CORBA
• Common Object Request Broker Architecture
• La comunicazione tra applicazioni non è diretta
ma è mediata
Sottorete A
skeleton
Sottorete B
servente
ORB
(iiop)
ORB
cliente
stub
cliente
stub
Marco Piastra
Breve introduzione a Java - 56
Naming Service
• Il Naming Service serve a pubblicare oggetti
serventi a beneficio dei potenziali clienti
– gli oggetti servente vengono registrati in base ad un nome
simbolico
– i clienti possono ‘agganciare’ i serventi usando questo nome
– il Naming Service è solitamente realizzato da un processo
separato
skeleton
ORB
servente
nome
Marco Piastra
Breve introduzione a Java - 57
Modello industriale
• Java non nasce da un progetto accademico o
non-profit
• I requisiti di progetto di Java sono quindi:
– tecnici;
– ingegneristici;
– di contesto (cioè di mercato).
• I requisiti tecnici sono evidenti nel progetto del
modello astratto
• I requisiti ingegneristici sono evidenti nel modello
implementativo e nell’idea di piattaforma
• (Per capire i requisiti di mercato, si pensi a chi
comanda il gioco)
Marco Piastra
Breve introduzione a Java - 58
L’idea di piattaforma
• Uno dei grossi problemi della costruzione
software dal punto di vista ingegneristico è la
grande quantità di aspetti dipendenti da una
piattaforma specifica (e.g. Windows NT, Linux)
• In questo senso, la storia dei linguaggi di
programmazione registra numerosi insuccessi:
– il Pascal fu definito senza specificare le funzioni di I/O;
– il C (ed il C++) hanno un insieme di librerie standard limitato
(e.g. non c’è grafica o networking);
– il modello astratto di Common Lisp e Prolog è poco adatto alla
gestione grafica interattiva (e.g. multithreading).
Marco Piastra
Breve introduzione a Java - 59
Java come piattaforma
java.util
Classe in bytecode
java.io
Classe in bytecode
java.lang
Classe in bytecode
Macchina
virtuale
java.math
Classe in bytecode
java.awt
Classe in bytecode
java.beans
Classe in bytecode
java.rmi
Classe in bytecode
java.sql
Classe in bytecode
java.rmi
Classe in bytecode
javax.servlet
Classe in bytecode
javax.ejb
Classe in bytecode
...
Classe in bytecode
java.security
Classe in bytecode
Marco Piastra
Breve introduzione a Java - 60
Per Ulteriori Approfondimenti
• Tutorial on-line
– http://www.javasoft.com/docs/books/tutorial
– Consigli:
» saltare (in prima lettura) la parte sulle applet
» seguire (come minimo): Learning the Java Language,
Essential Java Classes, Collections.
» consigliati: Creating a GUI, Java Beans
• Libri
– Arnold, K., Gosling, J., The Java Programming Language Second Edition, Addison-Wesley, 1998.
– Bishop, J., Java Gently - Second Edition, Addison-Wesley,
1998.
Marco Piastra