Qué es Monitor en Java

1. Ejemplo de subprocesos múltiples sin usar Monitor en Java
2. Ejemplo de subprocesos múltiples usando Monitor en Java

Este tutorial presenta qué es un monitor y cómo usarlo en la programación Java.

Monitor es un término que se refiere a la sincronización de procesos. Esto es usado inicialmente por los sistemas operativos, y ahora la mayoría de los lenguajes de programación lo usan.

En Java, se utiliza para lograr la sincronización de procesos en un entorno de subprocesos múltiples. Ayuda a lograr la exclusión mutua entre procesos. El proceso externo no puede acceder al código escrito en el monitor, por lo que no se produce una situación de espera y espera.

Java usa el método synchronized() para crear un monitor, y cualquier objeto puede servir como monitor. Un monitor usa una función asociada con un elemento / variable de datos específico como bloqueo. Cuando un hilo intenta acceder y modificar esos datos, el monitor restringe ese proceso y se mantiene hasta que el hilo actual complete su ejecución.

Entendamos el monitor con algunos ejemplos.

Ejemplo de subprocesos múltiples sin usar Monitor en Java

Primero entendamos qué sucede si no usamos el monitor en la programación de subprocesos múltiples. En este ejemplo, creamos dos hilos y los ejecutamos. Podemos notar que la ejecución de subprocesos es completamente aleatoria, y cada vez que thread1 o thread2 inician la ejecución. En el caso del monitor, solo un hilo puede ejecutar su código a la vez, y el segundo hilo debe esperar ese tiempo, pero aquí no usamos monitor, por lo que el resultado es completamente desordenado. Vea el ejemplo a continuación.

class MonitorDemo {
  void showMsg(String msg) { // synchronized method
    for (int i = 1; i <= 5; i++) {
      System.out.println(msg);
      try {
        Thread.sleep(500);
      } catch (Exception e) {
        System.out.println(e);
      }
    }
  }
}
class Thread1 extends Thread {
  MonitorDemo m;
  Thread1(MonitorDemo m) {
    this.m = m;
  }
  public void run() {
    m.showMsg("thread1");
  }
}
class Thread2 extends Thread {
  MonitorDemo m;
  Thread2(MonitorDemo m) {
    this.m = m;
  }
  public void run() {
    m.showMsg("thread2");
  }
}
public class SimpleTesting {
  public static void main(String args[]) {
    MonitorDemo obj = new MonitorDemo();
    Thread1 t1 = new Thread1(obj);
    Thread2 t2 = new Thread2(obj);
    t1.start();
    t2.start();
  }
}

Producción :

thread1
thread2
thread1
thread2
thread1
thread2
thread1
thread2
thread1
thread2

Ejemplo de subprocesos múltiples usando Monitor en Java

Aquí, creamos un monitor en este ejemplo, y marcamos el método showMsg() como sincronizado. Entonces, solo un hilo puede acceder a esto a la vez. Notará la salida esta vez; el segundo subproceso comienza la ejecución solo después de completar el primer subproceso que sincroniza el código, y este es el beneficio del monitor. Es útil en la programación de subprocesos múltiples cuando varios subprocesos solicitan el mismo recurso. Necesitamos crear un sistema de este tipo para evitar cualquier problema de estancamiento o inanición. Vea el ejemplo a continuación.

class MonitorDemo {
  synchronized void showMsg(String msg) { // synchronized method
    for (int i = 1; i <= 5; i++) {
      System.out.println(msg);
      try {
        Thread.sleep(500);
      } catch (Exception e) {
        System.out.println(e);
      }
    }
  }
}
class Thread1 extends Thread {
  MonitorDemo m;
  Thread1(MonitorDemo m) {
    this.m = m;
  }
  public void run() {
    m.showMsg("thread1");
  }
}
class Thread2 extends Thread {
  MonitorDemo m;
  Thread2(MonitorDemo m) {
    this.m = m;
  }
  public void run() {
    m.showMsg("thread2");
  }
}
public class SimpleTesting {
  public static void main(String args[]) {
    MonitorDemo obj = new MonitorDemo();
    Thread1 t1 = new Thread1(obj);
    Thread2 t2 = new Thread2(obj);
    t1.start();
    t2.start();
  }
}

Producción :

thread1
thread1
thread1
thread1
thread1
thread2
thread2
thread2
thread2
thread2