Productor-Consumidor

El problema del productor-consumidor

El problema del productor-consumidor es un problema de sincronización entre diferentes procesos. Hay tres entidades en este problema:

• Un productor
• Un consumidor
• Un buffer (almacén)

Tanto el productor como el consumidor acceden al buffer para producir y consumir elementos, respectivamente. El productor produce elementos y los almacena en el buffer, mientras que el consumidor consume elementos del buffer.

Si el buffer está vacío, entonces el consumidor espera a que el productor coloque un elemento, que consumirá después de que el productor lo haya colocado.

El buffer de memoria tiene un tamaño fijo. Si está lleno, el productor espera a que el consumidor consuma un elemento antes de colocar uno nuevo. El productor y el consumidor no pueden acceder al buffer al mismo tiempo, es decir, es mutuamente exclusivo. Cada proceso debe esperar a que el otro termine su trabajo en el búfer antes de poder acceder a él.

Implementación en Java

Para ilustrar cómo funciona la comunicación entre hilos en la práctica, vamos a explorar un ejemplo práctico. Imaginemos una cocina de un restaurante de comida rápida con dos empleados: un cocinero que prepara hamburguesas (el productor) y un mesero que las sirve (el consumidor).

Podemos ver un primer enfoque al problema en el siguiente código:

class Cocina {
    private int hamburguesa;

    public synchronized void prepararHamburguesa(int numero) {
        this.hamburguesa = numero;
        System.out.println("Chef preparó hamburguesa #" + numero);
    }

    public synchronized int servirHamburguesa() {
        System.out.println("Mesero sirvió hamburguesa #" + hamburguesa);
        return hamburguesa;
    }
}

class Chef implements Runnable {
    Cocina cocina;

    public Chef(Cocina cocina) {
        this.cocina = cocina;
        new Thread(this, "Chef").start();
    }

    public void run() {
        int i = 0;
        while(true) {
          try {
              Thread.sleep(1000);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          cocina.prepararHamburguesa(i++);
        }
    }
}

class Mesero implements Runnable {
    Cocina cocina;

    public Mesero(Cocina cocina) {
        this.cocina = cocina;
        new Thread(this, "Mesero").start();
    }

    public void run() {
        while(true) {
            cocina.servirHamburguesa();
        }
    }
}

class Restaurante {
    public static void main(String args[]) {
        Cocina cocina = new Cocina();
        Chef chef = new Chef(cocina);
        Mesero mesero = new Mesero(cocina);
        System.out.println("Restaurante en funcionamiento");
    }
}

Veamos lo que ocurre en esta implementación, tiene varios problemas:

1. El cocinero puede preparar múltiples hamburguesas antes de que el mesero sirva una.
2. El mesero puede servir la misma hamburguesa más de una vez.
3. El cocinero y el mesero no están sincronizados.

Para resolver estos problemas, necesitamos implementar un mecanismo de comunicación entre los hilos. En Java, podemos hacerlo utilizando los métodos wait(), notify() y notifyAll().

Implementación usando wait() y notify()

Para solucionar los problemas anteriores, necesitamos hacer que el cocinero espere a que el mesero sirva la hamburguesa antes de preparar otra. Del mismo modo, el mesero debe esperar a que el cocinero prepare una hamburguesa antes de servirla.

Para lograr esto, vamos a modificar la clase Cocina de la siguiente manera:

class Cocina {
    private int hamburguesa;
    private boolean hamburguesaLista = false;

    public synchronized void prepararHamburguesa(int numero) {
        while(hamburguesaLista) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.hamburguesa = numero;
        hamburguesaLista = true;
        System.out.println("Chef preparó hamburguesa #" + numero);
        notify(); // Notificar al mesero que la hamburguesa está lista
    }

    public synchronized int servirHamburguesa() {
        while(!hamburguesaLista) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        hamburguesaLista = false; // Se consumió la hamburguesa
        System.out.println("Mesero sirvió hamburguesa #" + hamburguesa);
        notify(); // Notificar al chef que la hamburguesa fue servida
        return hamburguesa;
    }
}

En esta nueva implementación vemos:

1. Usamos una variable booleana hamburguesaLista para controlar el estado.
2. El chef espera si ya hay una hamburguesa lista, evitando la sobreproducción.
3. El mesero espera si no hay hamburguesa lista, evitando servir algo que no existe.
4. Ambos métodos usan notify() para avisar al otro hilo cuando pueden proceder.

Esta implementación asegura una perfecta sincronización entre producción y consumo, evitando los problemas de la versión anterior.