Programmazione concorrente in Java

• Teoria

  • Scarica gli appunti delle lezioni

• Esercizi

  1. Thread, costruttori e parametri (★☆☆) ✓

     Il metodo run ereditato dalla classe Thread non prevede parametri, ma può accedere direttamente a tutti gli attributi della sottoclasse.
     Per passare uno o più parametri a un thread, si dichiarano uno o più attributi, e si definisce un costruttore con uno o più parametri in ingresso.
     In questo modo i parametri possono essere passati al costruttore, il costruttore inizializza gli attributi, e il metodo run può utilizzarli.

     Scarica il progetto parametri.zip e completa il main della classe Test, utilizzando correttamente i costruttori dei thread Saluto e Contatore.

  2. Padroni, schiavi e l'algoritmo di Euclide (★★☆) ✓

     L'algoritmo di Euclide calcola il Massimo Comun Divisore (MCD) tra due numeri interi a e b, senza bisogno di scomporli in fattori primi.
     Scoperto più di 2300 anni fa, al giorno d'oggi il suo pseudocodice può essere scritto così:

     while a ≠ b
       if a > b
         a ← a − b
       else
         b ← b − a
     return a
     

     Se uno dei due numeri è molto più grande dell'altro (ad es. a ≅ 10¹² e b ≅ 10), l'algoritmo può impiegare più di un minuto per calcolare il risultato.
     Per non far "congelare" il programma conviene eseguire il calcolo in background, delegandolo a un thread secondo uno schema Master/Slave.

     Il Master, che in questo corrisponde al main

     1. prende in input due interi
     2. passa i due numeri a un thread Slave e lo avvia
     3. è libero di prendere in input altri interi e avviare altri Slave, senza aspettare l'esito dei calcoli

     Mentre ogni thread Slave

     1. prende i due interi passati come parametri
     2. calcola il MCD, stampa il risultato e termina

     Scarica il progetto euclide.zip, aggiungi alla classe Slave due attributi di tipo long, il costruttore appropriato e il metodo run,
     e completa il metodo main della classe Master, gestendo l'input e avviando i thread all'interno di un ciclo infinito while(true){ }.

  3. Gestione degli interrupt (★☆☆) ✓

     Simuliamo il lancio di due dadi con un programma in Java in cui ogni dado è un thread indipendente.

     • Definisci il thread Dado come un contatore ciclico da 1 a 6 che, quando riceve un interrupt, esce dal ciclo e stampa il numero a cui è arrivato.
     • Scrivi un programma che lancia due dadi, attende che l'utente prema invio e infine invia un interrupt ai due dadi.
     • Se vuoi due risultati veramente indipendenti, fai partire il contatore da un numero casuale tra 1 e 6 con (int)(1+Math.random()*6);

  4. Condivisione di risorse fra thread (★★☆) ✓

     Adele è una zia generosa che apre un conto corrente per quello spendaccione di suo nipote Bruno. In maniera indipendente l'uno dall'altro, Adele versa dei soldi sul conto e Bruno li preleva. Simuliamo questa situazione con un programma in Java in cui Adele e Bruno siano due thread che condividono la stessa risorsa, il conto.

     • Definisci la classe Conto, con un saldo di tipo double inizialmente pari a zero e i metodi versaImporto(double importo), prelevaImporto(double importo) e toString() che restituisce il saldo in euro. Supponi che il saldo possa essere negativo.
     • Definisci il thread Zia, che per 100 volte versa €100,00 sul conto.
     • Definisci il thread Nipote, che per 100 volte preleva €100,00 dal conto,
     • Scrivi un programma che istanzia un conto e stampa il saldo iniziale; quindi avvia una zia e un nipote e, una volta terminati, stampa il saldo finale.
     • Il saldo iniziale e il saldo finale coincidono? Se no, perché? E come si risolve il problema in Java?

  5. Cooperazione fra thread (★★★)

     Nel problema del Produttore/Consumatore (*) due thread si scambiano dati attraverso un buffer condiviso di dimensione finita. Il produttore genera i dati e li scrive nel buffer; il consumatore legge i dati dal buffer e li utilizza. Il problema è evitare che il produttore scriva un dato se il buffer è pieno, e che il consumatore legga un dato se il buffer è vuoto. Per semplicità in questo esercizio supporremo che il buffer abbia dimensione unitaria.

     +----------+      +----------+      +----------+
     | Producer | ===> |  Buffer  | ===> | Consumer |
     +----------+      +----------+      +----------+
     

     • Definisci la classe Buffer, con gli attributi dato di tipo intero e pieno di tipo booleano,
       e i metodi mettiDato(int dato) di tipo void e togliDato() che restituisce un numero di tipo intero.
     • Definisci il thread Producer che mette nel buffer i numeri da 0 a 9.
     • Definisci il thread Consumer che per 10 volte toglie un numero dal buffer e lo scrive su console.
     • Scrivi un programma che istanzia un buffer e avvia un produttore e un consumatore.
       Verifica che siano stampati una volta sola tutti i numeri da 0 a 9.
     • Modifica il programma in modo che avvii due produttori e due consumatori, se necessario modificando anche i metodi del Buffer.
       Verifica che siano stampati due volte tutti i numeri da 0 a 9.

     (*) Il problema del produttore/consumatore si presenta spesso nella progettazione di sistemi informatici e di telecomunicazioni. Un esempio reale è un server che legge dati da un database e li invia a un client attraverso un canale di trasmissione, affidando i due compiti a thread indipendenti.