Estrategia "esperar-notificar-notificar a todos"

"¡Hola, amigo!"

"Quiero profundizar con usted con respecto a la notificación de espera. Los métodos de notificación de espera proporcionan un mecanismo conveniente para que los subprocesos interactúen. También se pueden usar para construir mecanismos complejos de alto nivel para la interacción de subprocesos".

"Comenzaré con un pequeño ejemplo. Supongamos que tenemos un programa para un servidor que debe realizar varias tareas creadas por los usuarios a través de un sitio web. Los usuarios pueden agregar varias tareas en diferentes momentos. Las tareas consumen muchos recursos, pero nuestro servidor 8 -El procesador central puede hacer frente. ¿Cómo debemos realizar las tareas en el servidor?

"Primero, crearemos un grupo de subprocesos de trabajo, tantos como núcleos de procesador haya. Cada subproceso podrá ejecutarse en su propio núcleo: los subprocesos no interferirán entre sí y los núcleos del procesador no siéntate en reposo."

"En segundo lugar, crearemos un objeto de cola donde se agregarán las tareas de los usuarios. Los diferentes tipos de tareas corresponderán a diferentes objetos, pero todos implementarán la interfaz Runnable para que puedan ejecutarse".

"¿Podría darme un ejemplo de un objeto de tarea?"

"Échale un vistazo:"

class Factorial implements Runnable
{
 public int n = 0;
 public long result = 1;

 public Factorial (int n)
 {
  this.n = n;
 }

 public void run()
 {
  for (int i = 2; i <= n; i++)
   result *= i;
 }
}

"Hasta ahora, todo bien."

"Genial. Entonces examinemos cómo debe verse un objeto de cola. ¿Qué me puedes decir al respecto?"

"Debe ser seguro para subprocesos. Se carga con objetos de tarea mediante un subproceso que los recibe de los usuarios, y luego los subprocesos de trabajo recogen las tareas".

"Sí. ¿Y si nos quedamos sin tareas por un tiempo?"

"Entonces los subprocesos de trabajo deberían esperar hasta que haya más".

"Así es. Ahora imagina que todo esto se puede construir en una sola cola. Compruébalo:"

public class JobQueue
{
 ArrayList jobs = new ArrayList();

 public synchronized void put(Runnable job)
 {
  jobs.add(job);
  this.notifyAll();
 }

 public synchronized Runnable getJob()
 {
  while (jobs.size() == 0)
   this.wait();

  return jobs.remove(0);
 }
}

"Tenemos un método getJob que verifica si la lista de tareas está vacía. Luego, el hilo se duerme (espera) hasta que aparece algo en la lista".

"También existe el método put , que le permite agregar una nueva tarea a la lista. Tan pronto como se agrega una nueva tarea, se llama al método notificar a todos . Llamar a este método despierta todos los subprocesos de trabajo que se quedaron dormidos dentro del método getJob".

"¿Puedes recordar de nuevo cómo funcionan los métodos de esperar y notificar?"

"El método de espera solo se llama dentro de un bloque sincronizado, en un objeto mutex. En nuestro caso: esto. Además, suceden dos cosas:

1) El hilo se duerme.

2) El subproceso libera temporalmente el mutex (hasta que se despierta).

"Después de eso, otros subprocesos pueden ingresar al bloque sincronizado y adquirir ese mismo mutex".

"El método de notificación también solo se puede llamar dentro del bloque sincronizado de un objeto mutex. En nuestro caso: esto. Además, suceden dos cosas:"

1) Todos los subprocesos que esperan en este objeto mutex se despiertan.

2) Una vez que el subproceso actual sale del bloque sincronizado, uno de los subprocesos despiertos adquiere el mutex y continúa su trabajo. Cuando libera el mutex, otro subproceso despierto adquiere el mutex, etc.

“Es muy parecido a un autobús. Entras y quieres pagar tu pasaje, pero no hay conductor. Así que te ‘duermes’. Eventualmente, el autobús está lleno, pero todavía no hay nadie a quien darle el pasaje. llega y dice: «Tarifa, por favor». Y este es el comienzo de…"

"Interesante comparación. Pero, ¿qué es un autobús?"

"Julio explicó esto. Se usaron estas cosas raras en el siglo XXI".