Ejercicio Concurrencia con Semáforos en Java.

Os dejo un ejercicio de concurrencia en Java usando semáforos.


En una cadena de montaje existe un robot encargado de colocar productos de 3 tipos diferentes (1, 2 o 3) en la cadena de montaje. Otros robots, retiran los productos de la cadena de montaje para realizar su empaquetado, teniendo en cuenta que están especializados en un solo tipo de producto (1, 2 o 3), ignorando los que no son de su tipo. Finalmente, se quiere llevar un control del total de productos empaquetados (independientemente de su tipo).

Modelar utilizando semáforos el sistema descrito con las siguientes indicaciones:

• Modelar cada robot como una hebra (1 colocador y 3 empaquetadores, uno para cada tipo de producto).
• Los productos son colocados de uno en uno en la cadena, y solamente en posiciones libres (se puede considerar que en la cadena de montaje caben un máximo N de elementos). Si no hay posiciones libres el robot colocador tendrá que esperar hasta que algún producto sea retirado de la cadena.
• Los robots empaquetadores se especializan en un tipo de producto (1, 2 o 3) en tiempo de inicialización.
•  Los robots empaquetadores comprueban si hay algún elemento de su tipo en la cadena ignorando los productos que no sean de su tipo. Si hay algún producto de su tipo lo retiran de la cadena (sólo 1 producto cada vez) y la posición queda libre para colocar nuevos productos, en caso contrario se quedan a la espera de que haya nuevos productos.
• Los robots empaquetadores de distinto tipo pueden funcionar a la vez.
• Tanto el colocador como los empaquetadores nunca acaban.
• Cada vez que un robot empaquetador procesa un producto, la cuenta total de productos empaquetados debe aumentar y mostrarse un mensaje por pantalla.

public class Robots {
 static int tam = 10;
 static int [] cadena = new int [tam];
 
 static Semaphore coloco=new Semaphore(tam, true);;
 static Semaphore [] puedoemp =  {new Semaphore(0), new Semaphore(0), new Semaphore(0)};
 static int nemp = 0; // necesita un mutex
 static Semaphore mutex = new Semaphore(1, true);
 static Random r = new Random();
 
 public static class Colocador extends Thread{
  public void run(){
   int i, n;
   while(true){
    try {
     n = r.nextInt(3)+1;
     System.out.println("Produciendo tipo "+ n);
     sleep(r.nextInt(1000));
     coloco.acquire();
     i=0;
     while(cadena[i] != 0) i++;
     //cuando encuentra un sitio vacío, sale del bucle y puede colocar
     cadena[i]  = n;
     System.out.println("Coloco un producto "+ n + " en la posición "+ i +"\n"+ Arrays.toString(cadena));
     puedoemp[n-1].release();

    } catch (InterruptedException e) {e.printStackTrace(); }
   }
  }
 }
 
 public static class Empaquetador extends Thread {
  private int tipo;
 
  public Empaquetador (int tipo){
   this.tipo = tipo;
 
  }
  public void run(){
   int i;
   while(true){
   try {
    puedoemp[tipo-1].acquire();
    
     i =0;
    while(cadena[i] != tipo) i++;
    sleep(r.nextInt(1000));
    System.out.println("Robot de tipo "+ tipo + " empaquetando el producto de la posición "+ i);
    cadena[i] = 0; //dejo el hueco
    coloco.release();
    sleep(2000);
    mutex.acquire();  //aumentar nemp
    nemp++;
    
    System.out.println("Aumenta el número de empaquetados: "+ nemp);
    
    mutex.release(); // 
    
    
   } catch (InterruptedException e) {e.printStackTrace();}
   }
  }
 }
 public static void main(String[] args){
  System.out.println("El tamaño de la cadena será de " + tam);
  Empaquetador  empaquetador1 = new Empaquetador(1);
  Empaquetador  empaquetador2 = new Empaquetador(2);
  Empaquetador  empaquetador3 = new Empaquetador(3);
  Colocador colocador = new Colocador();
  colocador.start();
  empaquetador1.start();
  empaquetador2.start();
  empaquetador3.start();
  
 }
}

.