View difference between Paste ID: ccs5NtWZ and LbWFgUH3

 /* 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
-	static final int NTHREAD=10;		    // numero di thread da creare
+        static final int MAX=4;
-	final int index;			    // indice del thread appena creato
+        final int index;
         Pipeline p;
-	// costruttore: memorizza l'indice del thread
+
-	CreaNThread(int i) {
+        CreaNThread(int i,Pipeline pipe) {
-		index = i;
+                index = i; p=pipe;
-	}
+        }
 
-	//codice da eseguire allo start del thread
+        public void run(){
-	public void run(){
+                p.threadBody(index);
-		Pipeline.threadBody(index);
+        }
-	}
+
-
+        public static void main(String args[]) throws InterruptedException {
-
+                int i;
                 Pipeline pipe= new Pipeline(MAX);
                 Thread t[] = new Thread[NTHREAD];
                 // crea 10 thread e li esegue
-	//il main crea i thread, attende la terminazione e stampa il valore finale
+                for(i=0;i<NTHREAD;i++) {
-	public static void main(String args[]) throws InterruptedException {
+                        t[i] = new CreaNThread(i,pipe);
-		int i;
+                        t[i].start();
-		Thread t[] = new Thread[NTHREAD];
+                }
 
-		// crea 10 thread e li esegue
+		// attende la terminazione dei thread
 		for(i=0;i<NTHREAD;i++) {
-			t[i] = new CreaNThread(i);
+			t[i].join();
-			t[i].start();
+	   	}
-		}
+                // stampa il valore finale della funzione, il valore atteso ed esce
                 pipe.stampavalore();
-		Pipeline x = new Pipeline; //creo un monitor
+
         }/*end of main*/
 }/*end of class*/
 
 
 
-		// stampa il valore finale della funzione, il valore atteso ed esce
+
-		System.out.println("Il valore finale della funzione " + i.valore() );
+
         int turno;
         int input[];
         int max;
 
         public Pipeline(int max){
                 turno=0;
                 input=new int[max];
-	private int count=0;	// privato: no accessi diretti!
+                this.max=max;
- 	int turno =0;
+                for(int i=0;i<max;i++)input[i]=i;
-	int input=0;		//sarà il valore di input della funzione successiva, e
+        }
-				//corrispondente al valore di output della funzione attuale
+
         synchronized int myfunction(int i) {
                 return 2*i+1;
-	// il metodo synchronized garantisce mutua esclusione sullo stesso oggetto
+        }
-	synchronized static void function() {
+
-
+        synchronized void threadBody(int i){
-		count+=1; //la mia funzione restituirà dunque il successivo
+                while(turno!=i)
-	}
+                try{
                     wait();
 
-	syncronized void threadBody(int i){
+                }catch(Exception e){}
-		while(turno!=i)wait(); //se il turno non è quello del thread allora il thread aspetta
+
                 for(int j=0;j<max;j++)
-		//esecuzione
+                        input[j]=myfunction(input[j]);
-		System.out.println("Thread "+i+" eseguito!");
+                System.out.println("Thread "+i+" eseguito!");
-
+                turno++;
-		//cambio valore dell'input per il prossimo thread
+                notifyAll();
-		input= function();
+        }
-
+
-		//turno successivo. Notifico a tutti  che ho finito il mio conto.
+        void stampavalore() {
-		//essendo dentro ad un while allora di ripartirà e nuovamente entrerà in ciclo solamente
+                System.out.print("Risultato: ");
-		//il thread con il permesso
+                for(int i=0;i<max;i++)System.out.print(input[i]+" ");
-		notifyAll();
+                System.out.println(".");
-	}
+        }
 }