corso java 2 - avanzato
DESCRIPTION
TRANSCRIPT
![Page 1: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/1.jpg)
Corso 2 Java
Programmazione Avanzata Giuseppe Dell’Abate
![Page 2: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/2.jpg)
Modulo 1
JDBC e Database
![Page 3: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/3.jpg)
Lezione 1
Le API di JDBC e JDBC2 • La libreria JDBC (Java Database Connectivity) contiene
un insieme di classi Java a disposizione dello sviluppatore che consente di utilizzare una serie di strumenti per l’interazione con un qualsiasi database server
• Un driver JDBC è un modulo software, dedicato ad uno specifico database, in grado di tradurre tutte le funzionalità fornite dall’interfaccia JDBC in comandi del linguaggio di interrogazione adottato dal DataBase (nella maggior parte dei casi si tratta di SQL).
![Page 4: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/4.jpg)
Lezione 1
Le API di JDBC e JDBC2 • Mostriamo di seguito i passi necessari per interrogare un
database e processare il risultato dell’interrogazione.
1. Caricare il driver JDBC per il database interessato
2. Apertura della connessione
3. Preparare l’esecuzione della query
4. Invio dell’interrogazione al database
5. Ciclo sull’oggetto ResultSet per leggere i dati della query
6. Chiusura della connessione
![Page 5: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/5.jpg)
Lezione 2
Il concetto di driver e connessione • Il ClassLoader Java si occupa di caricare in memoria le
librerie necessarie per la connessione
• Per ogni database vengono create delle classi java che implementano la specifica JDBC e consentono di poter eseguire tutte le operazioni necessarie per manipolare i dati.
![Page 6: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/6.jpg)
Lezione 2
Il concetto di driver e connessione • Per dialogare con il Database occorre predisporre una
connessione che fornisca il canale di comunicazione tra noi ed il database
• Per creare la connessione occorre impostare: URL, USER e PASSWORD
▫ URL: è utilizzato per indicare i parametri di connessione al DataBase
▫ USER: utente con cui vogliamo connetterci, esistente nel DB
▫ PASSWORD: password dell’utente
• Esempio:
▫ Connection con = DriverManager.getConnection (“jdbc:oracle:thin:@localhost:1521:orcl", "scott", "tiger");
![Page 7: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/7.jpg)
Lezione 3
Tipi di driver • In base al tipo di database utilizzato, dovremo scegliere il
suo Driver,ossia l’implementazione JDBC di quel database
• I Drivers si distinguono in base ai databases: ▫ per il Database Postgre: org.postgresql.Driver
▫ per il Database Oracle: oracle.jdbc.driver.OracleDriver
▫ per il Database Mysql: com.mysql.jdbc.Driver
▫ per il Database MicroSoft SQL Server : com.microsoft.jdbc.sqlserver.SQLServerDriver
• Esempio:
▫ Class.forName(“oracle.jdbc.driver.OracleDriver”);
![Page 8: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/8.jpg)
Lezione 4
Creare una istruzione SQL semplice String url = "jdbc:postgresql://SERVER-POSTGRESQL/esercitazioni";
String user = ""; String passwd = "";
Class.forName("org.postgresql.Driver");
Connection con = DriverManager.getConnection(url,user,passwd);
String sql = " SELECT * FROM STUDENTE ";
Statement stmt = con.Statement();
ResultSet rs=stmt.executeQuery(sql);
while (rs.next()) {
System.out.println(“Cognome: "+rs.getString("Cognome"));
System.out.println(“Nome: "+rs.getString("Nome"));
}
stmt.close();
con.close();
![Page 9: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/9.jpg)
Lezione 5
Creare una istruzione SQL preparata • Una istruzione preparata, a differenza del caso
precedente, utilizza l’interfaccia PrepareStatement invece di Statement.
• E’ consigliabile utilizzare PrepareStatement nel caso in cui si pensa di utilizzare frequentemente una query a fronte di argomenti diversi.
• L’uso del PrepareStatement consente di velocizzare i tempi di esecuzione, la fase di pre-elaborazione della query viene effettuata solo la prima volta.
![Page 10: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/10.jpg)
Lezione 5
Creare una istruzione SQL preparata String url = "jdbc:postgresql://SERVER-POSTGRESQL/esercitazioni";
String user = ""; String passwd = "";
Class.forName("org.postgresql.Driver");
Connection con = DriverManager.getConnection(url,user,passwd);
String sql = " SELECT * FROM STUDENTE where nome = ?";
PreparedStatement stmt = conn.prepareStatement(sql);
stmt.setString(1, "Mario");
ResultSet rs=stmt.executeQuery(sql);
while (rs.next()) {
System.out.println(“Cognome: "+rs.getString("Cognome"));
System.out.println(“Nome: "+rs.getString("Nome"));
}
stmt.close();
con.close();
![Page 11: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/11.jpg)
Lezione 6
Lanciare una store procedure • Nel database vengono salvate delle procedure che consentono di
eseguire una serie di elaborazioni. • Tali procedure possono essere invocate tramite JDBC. • Esempio: creiamo una tabella dal nome user ed una procedura che
inserisca un utente nella tabella -- Tabella user CREATE TABLE user ( id INTEGER, nome VARCHAR(45) ) -- Procedura inserimento utente CREATE PROCEDURE 'insertUser'(nomeUtente VARCHAR(45)) BEGIN INSERT INTO user(name) VALUES(nomeUtente); END
![Page 12: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/12.jpg)
Lezione 6
Lanciare una store procedure String url = "jdbc:postgresql://SERVER-POSTGRESQL/esercitazioni";
String user = ""; String passwd = "";
Class.forName("org.postgresql.Driver");
Connection con = DriverManager.getConnection(url,user,passwd);
CallableStatement storedProcedure = connection.prepareCall("{ call insertUser(?) }");
storedProcedure.setString(1, name);
storedProcedure.execute();
storedProcedure.close();
con.close();
![Page 13: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/13.jpg)
Lezione 7
Recuperare il risultato di una SELECT • Il risultato di una query viene mantenuta in un oggetto
ResultSet che consente di mantenere un puntatore sulle tabelle del database.
• Tramite questo oggetto è possibile scorrere il risultato della nostra query ed estrarre il risultato.
ResultSet rs=stmt.executeQuery(sql);
while (rs.next()) {
System.out.println(“Cognome: "+rs.getString("Cognome"));
System.out.println(“Nome: "+rs.getString("Nome"));
}
![Page 14: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/14.jpg)
Lezione 8
Accesso ai metadati • Tramite le API JDBC è possibile recuperare delle
informazioni inerenti il database, le tabelle, le connessioni.
• Tali informazioni vengono dette meta-dati in quanto servono per indicare la natura del dato.
• Per esempio Cognome è un metadato mentre Esposito è un dato; il primo serve per descrivere la natura del dato mentre il secondo è il dato
• I nomi delle tabelle, delle colonne, del database, la versione, le sue proprietà sono tutti meta-dati che servono per conoscere meglio il database.
![Page 15: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/15.jpg)
Lezione 8
Accesso ai metadati • Accesso ad alcune informazioni del database: nome,
versione, driver per la connessione. • Molte altre informazioni sono disponibili del risultato
della query usando “ResultSetMetaData”
String url = "jdbc:postgresql://SERVER-POSTGRESQL/esercitazioni";
String user = ""; String passwd = "";
Class.forName("org.postgresql.Driver");
Connection con = DriverManager.getConnection(url,user,passwd);
DatabaseMetaData dbmd = conn.getMetaData();
System.out.println( dbmd.getDatabaseProductName() );
System.out.println( dbmd.getDatabaseProductVersion());
System.out.println( dbmd.getDriverName() );
con.close();
![Page 16: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/16.jpg)
Modulo 2
Stream
![Page 17: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/17.jpg)
Lezione 1
Il concetto di stream di dati • Stream significa “flusso” e si riferisce ad un flusso di
bytes che rappresentano dei dati che vengono trasferiti da una sorgente ad una destinazione.
• I dati vengono scomposti nella loro composizione originaria cioè in bytes per poi essere trasferiti tramite cavo, wireless su una diversa destinazione per poi essere successivamente ricomposti in dati.
![Page 18: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/18.jpg)
Lezione 2
Il pacchetto java.io • Il package java.io è composto da due parti principali:
▫ stream di byte: utilizzati per gestire un flusso di byte (8 bit)
▫ stream di caratteri: impiegati per maneggiare un flusi di caratteri UNICODE(16 bit)
• Per ogni stream esistono i corrispondenti stream di input e di output
▫ stream di byte: InputStream ed OutputStream
▫ stream di caratteri: Reader e Writer
• Quando si parla semplicemente di stream si intende uno stream di qualunque tipo (di byte o di caratteri , di input o di output)
![Page 19: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/19.jpg)
Lezione 3
I tipi di stream
![Page 20: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/20.jpg)
Lezione 3
I tipi di stream • Esempio di una classe che legge i byte di un file passato
come parametro import java.io.*;
class ProvaInputStream {
public static void main(String[] args) throws IOException {
InputStream is = new FileInputStream(args[0]);
int b;
while ( (b = is.read()) != -1 )
System.out.println("Letto : " + (char)b);
}
}
![Page 21: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/21.jpg)
Lezione 3
I tipi di stream
![Page 22: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/22.jpg)
Lezione 3
I tipi di stream • Esempio di una classe che scrive dei dati in un file
import java.io.*; class ProvaOutputStream { public static void main(String[] args) throws
IOException { OutputStream os = new FileOutputStream(args[0]); int b; while ( (b = System.in.read()) != -1 ) os.write(b); } }
![Page 23: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/23.jpg)
Lezione 3
I tipi di stream
![Page 24: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/24.jpg)
Lezione 3
I tipi di stream • Esempio di una classe che legge dei dati da un file
import java.io.*; class ProvaReader { public static void main(String[] args) throws
IOException { Reader r = new FileReader(args[0]); int c; while ( (c = r.read()) != -1 ) System.out.println(“Leggo:” + (char)c); } }
![Page 25: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/25.jpg)
Lezione 3
I tipi di stream
![Page 26: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/26.jpg)
Lezione 3
I tipi di stream • Esempio di una classe che scrive dei dati in un file
import java.io.*; class ProvaWriter { public static void main(String[] args) throws IOException { Reader r = new InputStreamReader(System.in); Writer os = new FileWriter(args[0]); int b; while ( (b = r.read()) != -1 ) { os.write(b); os.flush(); } } }
![Page 27: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/27.jpg)
Lezione 6
Serializzazione di oggetti • E’ una tecnica che consente di poter salvare un oggetto, o
meglio renderlo persistente, e poi ripristinato
• Occorre implementare l’interfaccia java.io.Serializable ed occorre che tutti le proprietà siano serializzabili
• Per verificare si può usare il serialver -show. Apparirà una finestra nella quale metterete il nome completo della classe che volete esaminare. Se la classe è serializzabile apparirà un valore identificativo della classe stessa, altrimenti non apparirà nulla.
![Page 28: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/28.jpg)
Lezione 6
Serializzazione di oggetti • Salvare un oggetto
public void scrivi () {
try{
fos = new FileOutputStream ("restore.ser");
oos = new ObjectOutputStream(fos);
oos.writeObject(salvato);
oos.close();
}
catch (IOException ioe){
System.out.println("Errore:"+ioe.toString());
}
}
![Page 29: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/29.jpg)
Lezione 6
Serializzazione di oggetti • Caricare un oggetto:
public void leggi() { try{ fis = new FileInputStream ("restore.ser"); ois = new ObjectInputStream(fis); salvato = (TipoSalvato)(ois.readObject()); ois.close(); } catch (IOException ioe){ System.out.println("Errore:"+ioe.toString()); } }
• Operazione di cast da fare all’atto del readObject. Infatti essa ritorna un Object per cui tale operazione si rende necessaria
![Page 30: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/30.jpg)
Modulo 3
Networking
![Page 31: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/31.jpg)
Lezione 1
Il concetto di client/server • La comunicazione tra 2 host avviene in modalità client/server
in cui il client è colui che effettua la chiamata mentre il server è colui che la accetta e risponde.
• Al fine di creare un canale di comunicazione tra i 2 host si utilizza il Socket
• Socket significa presa e serve per tenere uniti i 2 host che intendono scambiarsi i dati sotto forma di bytes
• Pertanto nel Socket passa un flusso di byte che viene trasmesso tra host diversi collegati in rete
• Esistono due tipi di socket:
▫ TCP (Transport Control Protocol)
▫ UDP (User Datagram Protocol)
![Page 32: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/32.jpg)
Lezione 2
Connessione Socket/ServerSocket • I socket in Java sono implementati con quattro classi
distinte:
1. Socket: socket TCP lato client
2. ServerSocket: socket TCP lato server
3. DatagramSocket: socket UDP semplici e broadcast
4. MulticastSocket: socket UDP multicast
![Page 33: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/33.jpg)
Lezione 3
Le classi per il networking • Al fine di realizzare una connessione TCP dobbiamo
utilizzare le classi Socket e ServerSocket.
• Inoltre i dati serializzati in uno stream possono essere manipolati utilizzando le classi InputStream e OutputStream recuperate da Socket e ServerSocket tramite i metodi:
▫ InputStream getInputStream()
▫ OutputStream getOutputStream()
![Page 34: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/34.jpg)
Lezione 4
Realizzazione di un client import java.io.OutputStream; import java.net.Socket; public class Client { public static void main(String[] args) throws Exception { new Client().start(); } public void start() throws Exception { Socket socket = new Socket("localhost", 7777); OutputStream os = socket.getOutputStream(); byte [] ciao = "ciao".getBytes(); os.write( ciao ); os.flush(); os.close(); socket.close(); } }
![Page 35: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/35.jpg)
Lezione 5
Realizzazione di un server import java.io.DataOutputStream; import java.io.InputStream; import java.net.ServerSocket; import java.net.Socket; public class Server { public static void main(String[] args) throws Exception { new Server().start(); } public void start() throws Exception { ServerSocket serverSocket = new ServerSocket(7777); while (true) { Socket socket = serverSocket.accept(); InputStream is = socket.getInputStream(); byte [] messaggio = new byte[is.available()]; is.read( messaggio ); is.close(); socket.close(); System.out.println("Messaggio ricevuto: " + new String( messaggio ) ); break; } } }
![Page 36: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/36.jpg)
Modulo 4
Programmazione Multithread
![Page 37: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/37.jpg)
Lezione 1
Il concetto di processo e thread • Il Sistema Operativo può eseguire molti programmi
(MSWord, IExplorer, AdobeReader ecc)
• Ogni programma è composto da uno o più processi.
• Ogni processo è costituito da uno o più Thread
• Il Thread è una sezione di codice che viene eseguito indipendentemente da altri Thread all’interno dello stesso processo.
![Page 38: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/38.jpg)
Lezione 1
Il concetto di processo e thread • Il processo è una entità dinamica il cui stato varia nel
tempo ed a cui il Sistema Operativo assegna un’area di memoria composta da codice e dati (variabili globali e locali)
• Il Thread è una porzione di un processo che viene eseguito in modo indipendente. Il processo condivide le proprie variabili globali con i Thread ottimizzando, in questo modo, le risorse disponibili ed evitando la duplicazione dei dati.
• Il passaggio da un Thread ad un altro all’interno dello stesso processo, presenta delle tempistiche di “context switch”, cioè di cambio di contesto, molto veloci.
![Page 39: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/39.jpg)
Lezione 2 La classe Thread e l'interfaccia Runnable
• Per creare un Thread in Java è possibile utilizzare due scelte opzionali:
1. Estendere la classe Thread
2. Implementare l’interfaccia Runnable
• L’opzione è nata per permettere a classi già figlie di altre classi, di poter diventare dei Thread implementando Runnable (esempio nel seguito).
![Page 40: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/40.jpg)
Lezione 2 La classe Thread e l'interfaccia Runnable 1. Esempio di estensione:
public class ProvaThread extends Thread { @Override public void run(){ System.out.println("Hello Thread"); } } 2. Esempio di implementazione: public class ProvaRunnable implements Runnable { @Override public void run(){ System.out.println("Hello Runnable"); } }
![Page 41: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/41.jpg)
Lezione 2 La classe Thread e l'interfaccia Runnable • Classe di invocazione:
public class Start {
public static void main(String[] args) {
Thread t1 = new Thread( new ProvaThread());
t1.start();
Thread t2 = new Thread( new ProvaRunnable() );
t2.start();
}
} • Il comportamento nelle 2 diverse invocazioni è lo stesso.
Hello Thread
Hello Runnable
![Page 42: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/42.jpg)
Lezione 2 La classe Thread e l'interfaccia Runnable • Nel caso in cui una classe ha già un padre ma vogliamo che
diventi un thread, allora siamo tenuti ad usare l’interfaccia Runnable, perché in Java non esiste l’ereditarietà multipla.
public class Padre {} public class Figlio extends Padre {}
• La classe Figlio diventerà: public class Figlio extends Padre implements Runnable { @Override public void run(){ System.out.println("Hello Runnable"); } }
![Page 43: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/43.jpg)
Lezione 3
Le API per i thread • La nostra classe deve essere una sottoclasse della classe
astratta java.lang.Thread oppure deve implementare l’interfaccia Runnable, presente nella libreria del JDK
• richiamiamo i costruttori;
▫ public Thread();
▫ public Thread(String nome);
• l’esecuzione è avviata con il metodo start()
• il metodo run() contiene le operazioni da effettuare
![Page 44: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/44.jpg)
Lezione 4
Impostare le priorità • Ad ogni processo è assegnata una priorità ovvero un
valore intero positivo che varia tra due valori della classe Thread: MIN_PRIORITY e MAX_PRIORITY.
• Quando un thread viene creato la sua priorità è pari a NORM_PRIORITY
• se in un determinato istante esiste un thread nello stato Runnable che ha priorità maggiore di quello corrente, esso viene promosso (pre-empted) sostituendo il precedente che, pur rimanendo nello stato di Runnable, non avanzerà nella esecuzione
![Page 45: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/45.jpg)
Lezione 4
Impostare le priorità public class Priorita extends Thread {
public Priorita(String nome_thread){
super(nome_thread);
}
@Override
public void run(){
for (int i=0; i<4;i++)
System.out.println(getName());
}
}
![Page 46: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/46.jpg)
Lezione 4
Impostare le priorità public class StartPriorita {
public static void main(String[] args) {
Priorita thread3 = new Priorita("Thread con BASSA PRIORITA'");
thread3.setPriority(Thread.MIN_PRIORITY);
thread3.start();
Priorita thread1 = new Priorita("Thread con MEDIA PRIORITA'");
thread1.start();
Priorita thread2 = new Priorita("Thread con ALTA PRIORITA'");
thread2.setPriority(Thread.MAX_PRIORITY);
thread2.start();
}
}
![Page 47: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/47.jpg)
Lezione 4
Impostare le priorità • La JVM quando si accorge che esistono altri Thread con priorità più
elevata, sostituisce il Thread in esecuzione di ridotta priorità. L’esecuzione sarà diversa da sistema operativo e dal suo carico.
Thread con BASSA PRIORITA'
Thread con MEDIA PRIORITA'
Thread con ALTA PRIORITA'
Thread con ALTA PRIORITA'
Thread con ALTA PRIORITA'
Thread con ALTA PRIORITA'
Thread con ALTA PRIORITA'
Thread con MEDIA PRIORITA'
Thread con MEDIA PRIORITA'
Thread con MEDIA PRIORITA'
Thread con MEDIA PRIORITA'
Thread con BASSA PRIORITA'
Thread con BASSA PRIORITA'
Thread con BASSA PRIORITA’
Thread con BASSA PRIORITA ’
![Page 48: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/48.jpg)
Lezione 5
Lo stato dei thread • I Thread subiscono un passaggio di stato durante la loro
vita, dal momento in cui vengono creati fino a quando si conclude la loro esecuzione.
![Page 49: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/49.jpg)
Lezione 5
Lo stato dei thread 1. New: il Tread viene creato ma ancora non è stato
chiamato il metoto start(). In questo stato il thread non è ancora “vivo”
2. Runnable: è stato invocato il metodo start(), adesso il thread è “vivo” ma ancora non è stato schedulato per l’esecuzione. Il Thread è stato inserito nella coda di esecuzione ed aspetta il suo turno anche in base alla priorità rispetto agli altri thread
3. Running: il Thread è “vivo ed in esecuzione”. Esegue il codice di cui è stato programmato fino ad interruzione interna o esterna.
![Page 50: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/50.jpg)
Lezione 5
Lo stato dei thread 4. Waiting/blocked/sleeping: Il thread si trova nella
condizione di: 1. Wainting: il codice del Thread impone una attesa che sarà
interrotta quando si verificherà un evento richiesto
2. Blocked: è una attesa forzata a fronte di una risorsa di rete, di file system oppure a causa di un oggetto “loccato”
3. Sleeping: il codice del Thread impone una attesa che sarà interrotta quando terminerà il tempo di attesa
5. Dead: Il thread ha completato l’esecuzione del metodo run() e la sua vita è volta al termine. Vengono liberate le risorse in termini di oggetti allocati nell’HEAP della JVM.
![Page 51: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/51.jpg)
Lezione 6
Condivisione di dati tra thread • I thread possono tra loro condividere dei dati ed essere
informati nel momento in cui una data risorsa è disponibile.
• Per ottenere questo obiettivo si usano i metodi wait() e notify() della classe Object, pertanto disponibili su tutti gli oggetti java.
• L’esempio seguente simula la condivisione di un oggetto ( Ball ) che viene scambiato tra due Thread (Ping e Pong) creando una classica partita.
• Ping lancia la palla ed aspetta che Pong la riceva. Quando Pong notifica a Ping che l’ha ricevuta, allora Ping rilancia la pallina e si rimette in attesa.
![Page 52: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/52.jpg)
Lezione 6
Condivisione di dati tra thread public class Ping extends Thread { private Ball ball = null; public Ping(Ball ball) { this.ball = ball; } @Override public void run() { while (true) { System.out.println("ping"); synchronized (ball) { try { ball.wait(); } catch (InterruptedException ex) {} } } } }
![Page 53: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/53.jpg)
Lezione 6
Condivisione di dati tra thread public class Pong extends Thread {
private Ball ball = null;
public Pong(Ball ball) {
this.ball = ball;
}
@Override
public synchronized void run() {
while (true) {
System.out.println("pong");
synchronized (ball) {
ball.notify();
}
try {
Thread.sleep(1000);
} catch (InterruptedException ex) {
}
}
}
}
![Page 54: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/54.jpg)
Lezione 6
Condivisione di dati tra thread public class StartPingPong {
public static void main(String[] args) throws InterruptedException {
Ball ball = new Ball();
Ping ping = new Ping( ball );
ping.start();
Pong pong = new Pong( ball );
pong.start();
}
}
Esecuzione della classe StartPingPong provoca un palleggio infinito: ping
pong
ping
pong
ping
pong
…..
![Page 55: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/55.jpg)
Lezione 7
La sincronizzazione • L’accesso parallelo ad una risorsa ad opera di 2 o più
soggetti, in certi casi, può causare dei problemi, pertanto è necessario poter gestire queste situazioni.
• La sincronizzazione consente di disciplinare l’accesso ad un oggetto tramite la parola chiave synchronized che determina il lock dell’oggetto stesso e l’impossibilità ad opera di altri di potervi accedere.
• La sincronizzazione si usa solo sui metodi di una classe, sia statici che di istanza.
![Page 56: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/56.jpg)
Lezione 7
La sincronizzazione • Vediamo un esempio in cui 2 Thread accedono alla
stampante. Il primo che acquisisce il controllo della stampante potrà stampare per primo, il secondo dovrà aspettare il completamento dell’operazione e solo dopo stamperà.
• La sincronizzazione si applica ai metodi di istanze ed ai metodi static. Il metodo static in quanto unico, sincronizza l’accesso per tutti i Thread che intendono accedervi, a differenza dei metodi di istanza che invece sincronizzano l’accesso solo ai Thread che si riferiscono alla stessa istanza.
![Page 57: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/57.jpg)
Lezione 7
La sincronizzazione • La classe Stampante ha il metodo stampa() di tipo synchronized pertanto l’accesso è
sincronizzato per lo stesso Thread, cioè un oggetto di tipo Thread non può accedere in modo concorrente al metodo stampa().
public class Stampante {
public synchronized void stampa(String text) {
System.out.println( text );
try {
Thread.sleep(2000);
} catch (InterruptedException ex) {}
}
}
![Page 58: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/58.jpg)
Lezione 7
La sincronizzazione • La classe TestSinc crea 2 Thread usando la stessa istanza di TestSinc, pertanto l’accesso
alla risorsa sincronizzata viene rispettata
public class TestSinc extends Thread {
Stampante stampante = new Stampante();
public static void main(String[] args) {
TestSinc test1 = new TestSinc();
Thread t = new Thread(test1);
t.start();
Thread t2 = new Thread(test1);
t2.start();
}
@Override
public void run(){
stampante.stampa("prova");
}
}
![Page 59: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/59.jpg)
Lezione 7
La sincronizzazione • Mentre invece la classe TestSinc crea 2 Thread usando diverse istanze di TestSinc,
pertanto l’accesso alla risorsa sincronizzata NON viene rispettata.
public class TestSinc extends Thread {
Stampante stampante = new Stampante();
public static void main(String[] args) {
Thread t = new Thread(new TestSinc());
t.start();
Thread t2 = new Thread(new TestSinc());
t2.start();
}
@Override
public void run(){
stampante.stampa("prova");
}
}
![Page 60: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/60.jpg)
Lezione 7
La sincronizzazione • Se rendiamo static il metodo stampa() di tipo synchronized l’accesso è sincronizzato
per tutti i Thread, cioè tutti gli oggetti di tipo Thread non possono accedere in modo concorrente al metodo stampa().
public class Stampante {
public static synchronized void stampa(String text) {
System.out.println( text );
try {
Thread.sleep(2000);
} catch (InterruptedException ex) {}
}
}
![Page 61: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/61.jpg)
Lezione 9
Gestione dei lock sui thread • Per acquisire il lock su un oggetto è necessario definire
un metodo synchronized ed accedere ad esso.
• Il lock sull’oggetto viene rilasciato quando il metodo synchronized è completamente eseguito.
• Il metodo synchronized può acquisire il lock su altri oggetti o sull’oggetto stesso, invocando altri metodi synchronized.
• Se il metodo synchronized passa allo stato blocked/sleeping/waiting, non rilascia il lock sugli oggetto acquisiti in precedenza.
![Page 62: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/62.jpg)
Modulo 5
Collections
![Page 63: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/63.jpg)
Lezione 1
Le API per le strutture dati • Il Java Collections Framework è una libreria formata da un
insieme di interfacce e di classi che le implementano per lavorare con gruppi di oggetti.
• Le interfacce e le classi del Collections Framework si trovano nel package java.util
• Il Collections Framework comprende:
▫ Interfacce: rappresentano vari tipi di collezioni di uso comune.
▫ Implementazioni: sono classi concrete che implementano le inter-facce di cui sopra, utilizzando strutture dati efficienti.
▫ Algoritmi: funzioni che realizzano algoritmi di uso comune, quali algoritmi di ricerca e di ordinamento su oggetti che implementano le interfacce del Collections Framework.
![Page 64: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/64.jpg)
Lezione 1
Le API per le strutture dati
![Page 65: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/65.jpg)
Lezione 2
L'interfaccia Collection • Collection è la radice della gerarchia delle collection.
• Rappresenta gruppi di oggetti che possono essere duplicati o univoci, ordinati o meno.
• Le implementazioni concrete sono List e Set
![Page 66: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/66.jpg)
Lezione 3
Le strutture monodimensionali - List • Le List sono una sequenza ordinata di elementi che ammettono duplicati • Implementate con ArrayList, Vector e LinkedList
import java.util.*; public class Lista { public static void main(String[] args) { List list = new ArrayList(); list.add(1); list.add(1); list.add(1); Iterator iter = list.iterator(); while(iter.hasNext()) System.out.println("list: "+iter.next()); } }
![Page 67: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/67.jpg)
Lezione 4
Le strutture di tipo Set • I Set sono una sequenza di elementi che NON ammettono duplicati • Implementate con HashSet, LinkedHashSet, TreeSet
import java.util.*; public class Lista { public static void main(String[] args) { Set set = new HashSet(); set.add(1); set.add(1); set.add(1); Iterator ite = set.iterator(); while(ite.hasNext()) System.out.println("set:" + ite.next()); } }
![Page 68: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/68.jpg)
Lezione 5
Le strutture di tipo Map • Le Map sono delle sequenze di valori identificati dall’hashcode dell’oggetto
usato come chiave. • Implementate sono HashMap, Hashtable, LinkedHashMap, TreeMap
import java.util.*;
public class Lista {
public static void main(String[] args) {
Map map = new Hashtable();
map.put(1,"prova1");
map.put(1,"prova2");
map.put(1,"prova3");
Iterator iter_map = map.keySet().iterator();
while(iter_map.hasNext()){
Object obj = iter_map.next();
System.out.println("map_key:" + obj );
System.out.println("map_value:" + map.get(obj));
}
}
}
![Page 69: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/69.jpg)
Lezione 6
Gli oggetti Comparator
• Gli oggetti Comparator sono utilizzati per effettuare
confronti tra oggetti, in particolare il controllo viene effettuato sulle proprietà delle classi per determinare l’ordine tra le classi.
• E’ necessario implementare il metodo: ▫ public int compare(Object t1, Object t2)
• Nell’esempio seguente creiamo una classe che implementa Comparator per ordinare l’oggetto MyBean che viene inserito in una lista.
• Notare che l’ordinamento non è implicito e non avviene nel momento in cui gli oggetti vengono inseriti, ma è esplicito ed avviene solo dopo aver invocato il metodo Collections.sort()
![Page 70: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/70.jpg)
Lezione 6
Gli oggetti Comparator
package compare;
import java.util.Comparator;
public class Compare implements Comparator<MyBean> {
@Override
public int compare(MyBean t, MyBean t1) {
int x = t.getId();
int y = t1.getId();
return (x < y )? -1 : ((x==y) ? 0 : 1 );
}
}
![Page 71: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/71.jpg)
Lezione 6
Gli oggetti Comparator
package compare; public class MyBean { private int id; private String name; public MyBean(int id, String name){ this.id = id; this.name = name; } public int getId() { return id; } public String getName() { return name; } }
![Page 72: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/72.jpg)
Lezione 6
Gli oggetti Comparator
package compare;
import java.util.*;
public class Start {
public static void main(String[] args) {
//Creo i bean
MyBean mb1 = new MyBean(5,"ciccio");
MyBean mb2 = new MyBean(7,"pippo");
MyBean mb3 = new MyBean(9,"pluto");
//inserisco i bean nella lista
List<MyBean> list = new ArrayList<MyBean>();
list.add(mb2);
list.add(mb3);
list.add(mb1);
![Page 73: Corso Java 2 - AVANZATO](https://reader035.vdocuments.mx/reader035/viewer/2022081800/5484bd215906b599158b47e7/html5/thumbnails/73.jpg)
Lezione 6
Gli oggetti Comparator
….
System.out.println( "Visualizzo l'ordine nella lista prima dell'ordinamento");
for (MyBean myBean : list)
System.out.println( myBean.getId() );
//Creo il Comparator ed ordino la lista
Compare compare = new Compare();
Collections.sort(list, compare);
System.out.println( "Visualizzo l'ordine nella lista dopo l'ordinamento");
for (MyBean myBean : list)
System.out.println( myBean.getId() );
}
}