Beispiel für ein Mutex-Semaphor und einen Multithread-Wartemechanismus in Java

In diesem Artikel werden hauptsächlich Beispiele für Mutex-Sperren, Semaphoren und Multi-Thread-Wartemechanismen in der Java-Programmierung vorgestellt. Freunde, die es benötigen, können mehr über den Unterschied zwischen Mutex-Sperren und Semaphoren erfahren.

Mutex-Sperren und Semaphoren sind grundlegende Konzepte, die für die gleichzeitige Programmierung im Betriebssystem entwickelt wurden. Der konzeptionelle Unterschied zwischen Mutex-Sperren und Semaphoren besteht darin, dass es für dieselbe Ressource nur gegenseitige Ausschlusssperren gibt von 0 und 1, aber Semaphoren sind mehr als das. Mit anderen Worten, das Semaphor kann den gleichzeitigen Zugriff mehrerer Threads auf die Ressource ermöglichen, während auf den Mutex nur ein Thread gleichzeitig zugreifen kann.
Die Implementierung des Mutex in Java ist ReetranLock Beim Zugriff Bei einer synchronisierten Ressource muss das Objekt diese Sperre über die tryLock()-Methode erhalten. Wenn dies fehlschlägt, gibt es false zurück, und wenn es gelingt, gibt es true zurück. Bestimmen Sie anhand der zurückgegebenen Informationen, ob auf die synchronisierte Ressource zugegriffen werden soll. Schauen Sie sich das folgende Beispiel an:

public class ReentranLockExample {
 private static int count = 0;
 private static ReentrantLock reentrantLock = new ReentrantLock();
 static class MyThread extends Thread{
  @Override
  public void run() {
   super.run();
   try {
    while (true){
     boolean result = reentrantLock.tryLock();
     if (result){
      System.out.println(Thread.currentThread().getName() + "get the lock success and run the syn code " + count ++);
      reentrantLock.unlock();
     }else{
      System.out.println(Thread.currentThread().getName() + "get the lock failed and run the syn code " + count);
     }
     System.out.println(Thread.currentThread().getName() + "run the asyntronized code " + count);
     Thread.sleep(500);
    }
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
 }
 public static void main(String[] args){
  MyThread thread1 = new MyThread();
  MyThread thread2 = new MyThread();
  thread1.start();
  thread2.start();
 }
}

Das Semaphor entspricht einem Zähler. Wenn ein Thread auf eine Ressource zugreifen möchte, muss er zuerst das Semaphor dieser Ressource erhalten. und das Signal Der interne Zähler der Menge wird um 1 dekrementiert. Der interne Zähler des Semaphors ist größer als 0, was bedeutet, dass Ressourcen vorhanden sind, die verwendet werden können. Wenn der Thread die Verwendung einer Ressource beendet, muss der Semaphor dieser Ressource verwendet werden freigelassen werden. Eine der Funktionen eines Semaphors besteht darin, einen Thread für den Zugriff auf eine bestimmte Ressource anzugeben. Es muss nur initialisiert werden.

Die Implementierung von Semaphore in Java ist Semaphore, das während der Initialisierung als Ganzzahl übergeben wird, um den maximalen gleichzeitigen Zugriff auf Synchronisierungsressourcen anzugeben

public class SemaphoreExample {
 private static Semaphore semaphore = new Semaphore(2);
 private String lock = "lock";
 private static int count = 0;
 static class MyThread extends Thread {
  @Override
  public void run() {
   super.run();
   try {
    while (true) {
     semaphore.acquire();
     Thread.sleep(500);
     System.out.println(Thread.currentThread().getName() + "get the lock success and run the syn code " + count++);
     semaphore.release();
     Thread.sleep(500);
    }
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
 }
 public static void main(String[] args){
  MyThread thread1 = new MyThread();
  MyThread thread2 = new MyThread();
  MyThread thread3 = new MyThread();
  thread1.start();
  thread2.start();
  thread3.start();
 }
}

CountDownLatch implementiert einen Wartemechanismus, z. B. das Warten auf die Ankunft der Teilnehmer vor Beginn einer Konferenz. ConutDownLatch ist ein Zähler während der Initialisierung, um die zu wartende Anzahl anzugeben. Bei der gleichzeitigen Programmierung besteht die zu lösende Aufgabe darin, darauf zu warten, dass alle Threads einen bestimmten Punkt erreichen. Starten Sie einfach den nächsten Schritt, der ein wenig einem Meeting ähnelt. Das Meeting kann erst beginnen, wenn alle Teilnehmer angekommen sind

public class CountDownLatchExample {
 private static CountDownLatch mCountDownLatch = new CountDownLatch(3);
 static class MyThread extends Thread {
  int awaitTime;
  public MyThread(int i) {
   this.awaitTime = i;
  }
  @Override
  public void run() {
   super.run();
   try {
    while (true) {
     Thread.sleep(awaitTime);
     System.out.println(Thread.currentThread().getName() + "arrived " );
     mCountDownLatch.countDown();
     mCountDownLatch.await(); //可以指定等待时间
     System.out.println(Thread.currentThread().getName() + "start meeting " );
    }
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
 }
 public static void main(String[] args){
  MyThread thread1 = new MyThread(500);
  MyThread thread2 = new MyThread(1000);
  MyThread thread3 = new MyThread(2000);
  thread1.start();
  thread2.start();
  thread3.start();
 }
}

Zusammenfassung

Das obige ist der detaillierte Inhalt vonBeispiel für ein Mutex-Semaphor und einen Multithread-Wartemechanismus in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!