Was ist Monitor in Java

1. Multithreading-Beispiel ohne Verwendung von Monitor in Java
2. Multithreading-Beispiel mit Monitor in Java

In diesem Tutorial wird eingeführt, was ein Monitor ist und wie man ihn in der Java-Programmierung verwendet.

Monitor ist ein Begriff, der sich auf die Prozesssynchronisierung bezieht. Dies wird zunächst von den Betriebssystemen verwendet, und jetzt verwenden die meisten Programmiersprachen dies.

In Java wird es verwendet, um die Prozesssynchronisation in einer Multithreading-Umgebung zu erreichen. Es hilft, einen gegenseitigen Ausschluss zwischen Prozessen zu erreichen. Der äußere Prozess kann nicht auf den im Monitor geschriebenen Code zugreifen, sodass keine Warte- und Haltesituation auftritt.

Java verwendet die Methode synchronized(), um einen Monitor zu erstellen, und jedes Objekt kann als Monitor dienen. Ein Monitor verwendet eine Funktion, die einem bestimmten Datenelement/einer bestimmten Variablen zugeordnet ist, als Sperre. Wenn ein Thread versucht, auf diese Daten zuzugreifen und sie zu ändern, schränkt der Monitor diesen Prozess ein und hält ihn an, bis der aktuelle Thread seine Ausführung abgeschlossen hat.

Lassen Sie uns den Monitor anhand einiger Beispiele verstehen.

Multithreading-Beispiel ohne Verwendung von Monitor in Java

Lassen Sie uns zunächst verstehen, was passiert, wenn wir den Monitor nicht in der Multithreading-Programmierung verwenden. In diesem Beispiel haben wir zwei Threads erstellt und ausgeführt. Wir können feststellen, dass die Ausführung von Threads völlig zufällig ist und jedes Mal, wenn Thread1 oder Thread2 die Ausführung starten. Im Monitor-Fall kann nur ein Thread seinen Code gleichzeitig ausführen, und der zweite Thread sollte diese Zeit warten, aber hier haben wir Monitor nicht verwendet, daher ist das Ergebnis völlig unübersichtlich. Siehe das Beispiel unten.

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();
  }
}

Ausgabe:

thread1
thread2
thread1
thread2
thread1
thread2
thread1
thread2
thread1
thread2

Multithreading-Beispiel mit Monitor in Java

Hier haben wir in diesem Beispiel einen Monitor erstellt und die Methode showMsg() als synchronisiert markiert. Es kann also immer nur ein Thread darauf zugreifen. Diesmal werden Sie die Ausgabe bemerken; Der zweite Thread startet die Ausführung erst, nachdem der erste Thread abgeschlossen ist, der den Code synchronisiert, und dies ist der Vorteil des Monitors. Dies ist bei der Multithreading-Programmierung hilfreich, wenn mehrere Threads dieselbe Ressource anfordern. Wir müssen ein solches System schaffen, um Deadlock- oder Hungerprobleme zu vermeiden. Siehe das Beispiel unten.

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();
  }
}

Ausgabe:

thread1
thread1
thread1
thread1
thread1
thread2
thread2
thread2
thread2
thread2