Tema 5. Sincronización con Java

 1: public class Buffer {
 2:   private int cima, capacidad, vector[];
 3: 
 4:   public Buffer(int i) {
 5:     cima = 0;
 6:     capacidad = i;
 7:     vector = new int[i];
 8:   }
 9: 
10:   synchronized public int extraer(int id) {
11:     System.out.println(id+": espera para leer");
12:     while (cima == 0)
13:       try {
14:         wait();
15:       } catch (InterruptedException e){}
16:     notifyAll();
17:     return vector[--cima];
18:   }
19: 
20:   synchronized public void insertar(int elem,int id) {
21:    System.out.println(id+": espera para insertar");
22:    while (cima == capacidad)
23:      try {
24:       wait();
25:      } catch (InterruptedException e){}
26:    vector[cima]=elem;
27:    cima++;
28:    notifyAll();
29:   }
30: }

 1: public class Consumidor extends Thread {
 2:   int elem, id;
 3:   Buffer buffer;
 4: 
 5:   Consumidor(Buffer b, int numHilo) {
 6:     buffer = b;
 7:     id = numHilo;
 8:     System.out.println("CONSUMIDOR " + id +": entra");
 9:   }
10: 
11:   public void run () {
12:     try {
13:       elem = buffer.extraer(id);
14:       System.out.println(id + ": he leido " + elem);
15:     } catch (Exception e) {}
16:   }
17: }

 1: public class Productor extends Thread {
 2:   Buffer buffer;
 3:   int elem, id;
 4: 
 5:   Productor(Buffer b, int i, int numHilo) {
 6:     elem = i;
 7:     buffer = b;
 8:     id = numHilo;
 9:     System.out.println("PRODUCTOR " + id + ": entra");
10:   }
11: 
12:   public void run () {
13:     try {
14:       buffer.insertar(elem, id);
15:       System.out.println(id + ": inserta " + elem);
16:     } catch (Exception e) {}
17:   }
18: }

 1: public class ProductorConsumidor {
 2:   static Buffer buf = new Buffer(3);
 3:   static int numcons = 7;
 4:   static int numprods = 5;
 5: 
 6:   public static void main(String[] args) {
 7:      for(int i = 1; i <= numprods; i++)
 8:        new Productor(buf,i,i).start();
 9: 
10:      for(int k = 1; k <= 1_000_000_000; k++);
11:        System.out.println();
12: 
13:      for(int j = 1; j <= numcons; j++)
14:        new Consumidor(buf, j).start();
15: 
16:      System.out.println("Fin del hilo main");
17:   }
18: }

 1: public class SemaforoBinario {
 2:   protected int contador = 0;
 3: 
 4:   public SemaforoBinario(int valorInicial) {
 5:     contador = valorInicial; // 1 o 0
 6:   }
 7: 
 8:   synchronized public void WAIT () {
 9:     while (contador == 0 )
10:       try {
11:         wait();
12:       } catch (Exception e) {}
13:     contador--;
14:   }
15: 
16:   synchronized public void SIGNAL () {
17:     contador = 1;
18:     notify();
19:   }
20: }

 1: public class SemaforoGeneral extends SemaforoBinario {
 2: 
 3:   public SemaforoGeneral(int valorInicial) {
 4:     super(valorInicial); // numero natural
 5:   }
 6: 
 7:   synchronized public void  SIGNAL () {
 8:     contador ++;
 9:     notify();
10:   }
11: }

 1: import java.util.concurrent.ExecutorService;
 2: import java.util.concurrent.Executors;
 3: 
 4: public class ThreadPoolExample {
 5:     public static void main(String[] args) {
 6:         // Crear un ThreadPool con 4 hilos
 7:         ExecutorService executor = Executors.newFixedThreadPool(4);
 8: 
 9:         // Enviar tareas al ThreadPool
10:         for (int i = 1; i <= 10; i++) {
11:             int taskNumber = i;
12:             executor.submit(() -> {
13:                 System.out.println("Ejecutando tarea " + taskNumber + " en " + Thread.currentThread().getName());
14:             });
15:         }
16: 
17:         // Apagar el pool
18:         executor.shutdown();
19:     }
20: }

 1: // valac --pkg glib-2.0 thread_pool.vala
 2: 
 3: class Worker {
 4:   public string thread_name { private set; get; }
 5:   public int x_times { private set; get; }
 6:   public int priority { private set; get; }
 7: 
 8:   public Worker (string name, int x, int priority) {
 9:     this.priority = priority;
10:     this.thread_name = name;
11:     this.x_times = x;
12:   }
13: 
14:   public void run () {
15:     for (int i = 0; i < this.x_times ; i++) {
16:       print ("%s: %d/%d\n", this.thread_name, i + 1, this.x_times);
17:       Thread.usleep (1000000); // wait a second
18:     }
19:   }
20: }
21: 
22: public static int main (string[] args) {
23:   try {
24:     ThreadPool<Worker> pool = new ThreadPool<Worker>.with_owned_data ((worker) => {
25:         // Call worker.run () on thread-start
26:         worker.run ();
27:       }, 3, false);
28: 
29:     // Define a priority (otpional)
30:     pool.set_sort_function ((worker1, worker2) => {
31:         // A simple priority-compare, qsort-style
32:         return (worker1.priority < worker2.priority)? -1 : (int) (worker1.priority > worker2.priority);
33:       });
34: 
35:     // Assign some tasks:
36:     pool.add (new Worker ("Thread 1", 5, 4));
37:     pool.add (new Worker ("Thread 2", 10, 3));
38:     pool.add (new Worker ("Thread 4", 5, 2));
39:     pool.add (new Worker ("Thread 5", 5, 1));
40: 
41:     uint waiting = pool.unprocessed ();     // unfinished workers = 4
42:     uint allowed = pool.get_max_threads (); // max running threads = 3
43:     uint running = pool.get_num_threads (); // running threads = 3
44:     print ("%u/%u threads are running, %u outstanding.\n", running, allowed, waiting);
45:   } catch (ThreadError e) {
46:     print ("ThreadError: %s\n", e.message);
47:   }
48: 
49:   return 0;
50: }