Thread in Java

Il linguaggio Java implementa una forma semplificata dei Monitor. Come prima cosa vediamo come creare un thread in Java.

Creazione di Thread in Java

I thread in Java vengono creati estendendo la classe Thread e definendo il metodo run (il codice che il thread eseguirà). Per eseguire il nuovo thread è sufficiente invocare il metodo start.

public class CreaThread extends Thread {
    public void run() {
        System.out.println("Saluti dal thread " + this.getName());
    }
    
    public static void main(String args[]) {
        CreaThread t = new CreaThread();
        t.start();
    }
}

Oppure, se c’è esigenza di estendere altre classi, i thread possono anche essere creati come oggetti della classe Thread, al cui costruttore viene passato un oggetto che implementa l’interfaccia Runnable, che richiede l’implementazione del metodo run.

public class CreaThread2 implements Runnable {
    public void run() {
        System.out.println("Saluti dal thread "
                           + Thread.currentThread().getName());
    }

    public static void main(String args[]) {
        CreaThread2 r = new CreaThread2();
        Thread t = new Thread(r);
        t.start();
    }
}

Notare che in questo caso per stampare il nome del thread si deve usare il metodo currentThread() della classe Thread. Nella prima soluzione, invece, possiamo direttamente invocare getName() sull’oggetto corrente in quanto istanza della classe Thread.

Entrambi i programmi danno il seguente output:

> javac CreaThread.java
> java CreaThread
Saluti dal thread Thread-0
>

Come per i thead POSIX, possiamo anche “addormentare” un thread Java, in questo caso il tempo è dato in millisecondi ed è necessario gestire l’eccezione InterruptedException sollevata da sleep nel caso il thread t venga interrotto ad esempio tramite t.interrupt().

    public void run()  {
        try {
            sleep(1000); // attende un secondo
        } catch(InterruptedException e) {
            System.out.println("["+getName()+"]"+" Ah mi hanno interrotto!!");
            return; 
        } 

Esercizio 1: creazione, interruzione e attesa di thread

Creare n thread, rallentarli tramite sleep(), provare ad interromperne l’attesa utilizzando t.interrupt() e attendere la terminazione con t.join() (analogamente a quanto si fa con i thread POSIX), dove t è l’oggetto thread. Aggiungere opportune print per osservare l’esecuzione.

public class CreaTantiThread extends Thread {
    static final int NTHREAD=5;     // numero di thread da creare
    final int index;                // indice del thread appena creato

    // costruttore: memorizza l'indice del thread 
    CreaTantiThread(int i) {
        index = i;
    }
    
    // codice da eseguire allo startup del thread 
    public void run()  {
        try {
            // NOTA: se l'interruzione arriva prima della sleep viene
            // bufferizzata!
            sleep(2000);  // dorme per 2 secondi
        } catch(InterruptedException e) {
            System.out.println("["+getName()+"]"+" Ah mi hanno interrotto!!");
            return; 
        }
        // saluta ed esce
        System.out.println("Saluti dal thread " + getName());
    }

    /* main: crea i NTHREAD thread ne interrompe alcuni e attende la
       terminazione. NOTA: con join devo gestire InterruptedException,
       ma nessuno interrompera' mai le join di questo main quindi la 
       ignoriamo */
    public static void main(String args[]) throws InterruptedException {
        int i;
        Thread t[] = new Thread[NTHREAD];
        
        // crea 5 thread e li esegue
        for(i=0;i<NTHREAD;i++) {
            t[i] = new CreaTantiThread(i);
            t[i].start();
        }
        
        // interrompe il terzo thread
        t[3].interrupt();
        
        // attende la terminazione dei thread
        for(i=0;i<NTHREAD;i++) {
            t[i].join();
           }
        
        // saluta ed esce
        System.out.println("Saluti dal thread " + Thread.currentThread().getName());
    }
}

> java CreaTantiThread
[Thread-3] Ah mi hanno interrotto!!
Saluti dal thread Thread-0
Saluti dal thread Thread-2
Saluti dal thread Thread-1
Saluti dal thread Thread-4
Saluti dal thread main
>

I Monitor di Java

In Java è implementata una forma semplificata dei monitor con le seguenti caratteristiche:

• Ogni oggetto ha un mutex implicito utilizzato per garantire mutua esclusione sui metodi;
• I metodi sono eseguiti in mutua esclusione solo se dichiarati synchronized;
• Ogni oggetto ha un’unica condition implicita sulla quale si possono effettuare le operazioni standard wait(), notify(), notifyAll();
• se il metodo è statico allora il mutex è a livello di classe invece che di oggetto;
• è inoltre possibile sincronizzare parti di codice di un metodo non synchronized nel seguente modo:

  synchronized(this) {
          contatore=contatore+1
      }
  

  this indica a quale oggetto fare riferimento per ottenere il lock implicito. In questo caso è l’oggetto stesso ma è possibile indicare oggetti differenti e quindi sincronizzarsi utilizzando il mutex di tali oggetti.

NOTA: la sincronizzazione è “rientrante”: è possibile chiamare un metodo synchronized da un altro synchronized senza problemi (il mutex è già acquisito alla chiamata del primo metodo sincronizzato e viene mantenuto fino al ritorno del metodo o ad una eventuale terminazione prematura per via di un’eccezione non gestita)

Esercizio 2: sezione critica

Implementare due thread che lavorano su un contatore condiviso, osservare le usuali interferenze e rimediare ponendo il codice all’interno di metodi synchronized.

Suggerimento: mettere il contatore in una classe apposita (che fungerà da monitor) e implementare i metodi per l’incremento e la lettura/stampa del valore.

public class Interferenze extends Thread {
    static final int MAX=1000000;           // iterazioni massime
    Contatore c;                            // Monitor passato dal main

    // costruttore, memorizza il monitor nel campo c
    Interferenze(Contatore cont) {
        c=cont;
    }
    //   i thread incrementano MAX volte il contatore
    //   NOTA: non possono fare c.count++ perche' e' privato! 
    public void run() {
        int i;
        for (i=0;i<MAX;i++)
            c.incrementa();     // questo metodo e' in MUTEX perche' synchronized
    }

    //   il main crea i thread, attende la terminazione e stampa il contatore 
    public static void main(String args[]) throws InterruptedException {
        int j=0;
        Thread t[] = new Thread[2];
        Contatore cont = new Contatore(); // crea un singolo monitor
        
        // crea i 2 thread e li esegue
        for(j=0;j<2;j++) {
            t[j] = new Interferenze(cont); // passa il monitor ai thread
            t[j].start();
        }

        // attende la terminazione
        for(j=0;j<2;j++) t[j].join();

        // stampa il contatore, il valore atteso ed esce
        System.out.println("FINITO " + cont.valore() + " mi aspettavo " + MAX*2);
    }
}

/*  questa classe implementa un Monitor in cui e' possibile incrementare il valore 
 *  di un contatore da diversi thread in mutua esclusione.
 *  provare a togliere il 'synchronized' dal metodo incrementa per osservare 
 *  le interferenze */
class Contatore {
    private int count=0;    // privato: no accessi diretti!

    // il metodo synchronized garantisce mutua esclusione sullo stesso oggetto
    synchronized void incrementa() {
        //oppure: synchronized(this) {count++;}
        count++;
    }

    // non serve sincronizzarlo visto che lo usiamo alla fine dal main: gli altri
    // thread sono gia' terminati (la join garantisce che il main e' l'unico 
    // thread in esecuzione) inoltre la lettura non crea mai interferenze
    int valore() {
        return(count);
    }
}

Esercizio 3: produttore e consumatore

Implementare il problema del produttore e consumatore in Java. Testarlo con tanti produttori e tanti consumatori.

Suggerimento: seguire lo schema illustrato nella lezione sui monitor.