/* In Java, con i Monitor

Realizzare una pipeline (catena di montaggio) di N thread/processi.
Passare ai thread/processi una funzione f(i) (immagino
la funzione x=x+1) da applicare ai dati secondo lo schema:


Se f(i) è la funzione passata di thread T(i) il risultato sarà: */



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

    // costruttore: memorizza l'indice del thread
    CreaNThread(int i) {
        index = i;
    }

    //codice da eseguire allo start del thread
    public void run(){
        Pipeline.threadBody(index);
    }





    //il main crea i thread, attende la terminazione e stampa il valore finale
    public static void main(String args[]) throws InterruptedException {
        int i;
        Thread t[] = new Thread[NTHREAD];

        // crea 10 thread e li esegue
        for(i=0;i<NTHREAD;i++) {
            t[i] = new CreaNThread(i);
            t[i].start();
        }

        Pipeline x = new Pipeline; //creo un monitor





        // stampa il valore finale della funzione, il valore atteso ed esce
        System.out.println("Il valore finale della funzione " + i.valore() );






class Pipeline {
    private int count=0;    // privato: no accessi diretti!
    int turno =0;
    int input=0;        //sarà il valore di input della funzione successiva, e
                //corrispondente al valore di output della funzione attuale


    // il metodo synchronized garantisce mutua esclusione sullo stesso oggetto
    synchronized static void function() {

        count+=1; //la mia funzione restituirà dunque il successivo
    }


    syncronized void threadBody(int i){
        while(turno!=i)wait(); //se il turno non è quello del thread allora il thread aspetta

        //esecuzione
        System.out.println("Thread "+i+" eseguito!");

        //cambio valore dell'input per il prossimo thread
        input= function();

        //turno successivo. Notifico a tutti  che ho finito il mio conto.
        //essendo dentro ad un while allora di ripartirà e nuovamente entrerà in ciclo solamente
        //il thread con il permesso
        notifyAll();
    }

    int valore() {
        return(count);
    }
}