Implementierungsmethode der Thread-Synchronisation und des gegenseitigen Ausschlusses in der Java-Sprache

Die Java-Sprache ist eine Sprache, die in ihren Anfängen Multithreading eingeführt hat. Die Verwendung von Threads verleiht der Java-Sprache Glanz bei der gleichzeitigen Verarbeitung von Programmen. Allerdings waren Synchronisationsprobleme und gegenseitige Ausschlussprobleme zwischen Threads schon immer der Schlüssel zum Programmierprozess. In der Java-Sprache gibt es viele Möglichkeiten, Thread-Synchronisation und gegenseitigen Ausschluss zu implementieren. In diesem Artikel werden einige davon vorgestellt.

1. Verwenden Sie das Schlüsselwort „synchronized“, um Synchronisation und gegenseitigen Ausschluss zu erreichen.

Synchronized ist der grundlegendste Weg, um Synchronisation und gegenseitigen Ausschluss in der Java-Sprache zu erreichen. In Java verfügt jedes Objekt über einen Monitor. Wenn ein Thread in den Codeblock des Monitors eintritt, erhält er die Sperre des Objekts, und andere Threads, die den Sperrcodeblock ausführen müssen, können nur warten. Wenn ein Thread die Ausführung abschließt, wird die Sperre für das Objekt aufgehoben und andere Threads, die auf das Objekt warten, können den Codeblock betreten und den obigen Vorgang wiederholen.

Die Implementierung mit synchronisiert ist relativ einfach. Fügen Sie einfach das Schlüsselwort synchronisiert vor der Methode oder dem Codeblock hinzu, der synchronisiert werden muss. Zum Beispiel:

public synchronized void method1(){
  //...
}

Oder mit einem Codeblock:

public void method1(){
  synchronized(this) {
    //...
  }
}

Eine andere Form der Synchronisierung ist eine Klassensperre. Bei Verwendung von Klassensperren ist der Monitor ein Klassenobjekt derselben Klasse. Zum Beispiel:

public class MyClass {
  public static synchronized void method1(){
    //...
  }
}

Im obigen Code teilen alle Instanzen von MyClass dasselbe Class-Objekt der MyClass-Klasse.

2. Verwenden Sie ReentrantLock, um Synchronisierung und gegenseitigen Ausschluss zu erreichen.

Im Gegensatz zum synchronisierten Schlüsselwort ist ReentrantLock eine Klasse und kein Schlüsselwort. ReentrantLock verfügt über ähnliche Funktionen wie synchronisiert, bietet jedoch eine leistungsfähigere Steuerung der Synchronisierung und Mechanismen zum gegenseitigen Ausschluss. Im Gegensatz dazu ist die Verwendung von ReentrantLock flexibler. Beispielsweise kann eine faire Sperrenerfassung erreicht, die Anzahl der Sperrenerfassungen durch einen Thread gezählt werden usw.

ReentrantLock wird wie folgt verwendet:

ReentrantLock lock = new ReentrantLock();
lock.lock();
try{
  //...
} finally {
  lock.unlock();
}

ReentrantLock ist wiedereintrittsfähig, das heißt, derselbe Thread kann die Sperre mehrmals erhalten.

3. Verwenden Sie CountDownLatch, um eine Synchronisierung zu erreichen.

CountDownLatch ist eine Toolklasse für die Thread-Synchronisierung, die es einem oder mehreren Threads ermöglicht, darauf zu warten, dass ein anderer oder mehrere Threads die Ausführung abschließen. CountDownLatch stellt einen Countdown-Zähler bereit. Der wartende Thread muss die Countdown()-Methode aufrufen, um den Zähler um 1 zu verringern. Wenn der Zähler 0 ist, kann der wartende Thread weiter ausgeführt werden.

Mit CountDownLatch kann ein Thread auf den Start eines anderen Threads warten, bevor er fortfährt. Zum Beispiel:

//初始化计数器为1
CountDownLatch latch = new CountDownLatch(1);

//线程1
new Thread(new Runnable() {
  public void run(){
    //其他操作
    latch.countDown();
  }
}).start();

//线程2等待线程1启动完毕
latch.await();

//线程2继续执行

4. Verwenden Sie Semaphore, um Synchronisierung und gegenseitigen Ausschluss zu erreichen.

Semaphore ist eine weitere Java-Parallelitätstoolklasse, mit der Sie die Anzahl der Threads steuern können, die gleichzeitig auf bestimmte Ressourcen zugreifen. Semaphore verwaltet eine Reihe von Lizenzen. Wenn ein Thread eine Lizenz anfordert, kann er die Lizenz erhalten und mit der Ausführung fortfahren. Wenn die Lizenz aufgebraucht ist, müssen Sie warten, bis andere Threads die Lizenz zurückgeben, bevor Sie fortfahren.

Verwenden Sie Semaphore, um die Anzahl der Threads zu begrenzen, die gleichzeitig auf eine Ressource zugreifen, zum Beispiel:

//初始化Semaphore，设定同时允许2个线程访问
Semaphore semaphore = new Semaphore(2);

//其他线程请求许可证
semaphore.acquire();

//许可证使用完毕后释放
semaphore.release();

Zusammenfassung:

Die oben genannten Methoden sind mehrere Methoden, um Thread-Synchronisation und gegenseitigen Ausschluss in der Java-Sprache zu erreichen, darunter synchronisiert ist die Die grundlegendste Implementierungsmethode, ReentrantLock, bietet einen leistungsfähigeren Kontrollmechanismus, während CountDownLatch und Semaphore die Zusammenarbeit und Parallelität zwischen Threads gut steuern können. Bei der tatsächlichen Programmierung können durch eine angemessene Auswahl und flexible Verwendung dieser Tools Thread-Synchronisations- und gegenseitige Ausschlussprobleme in Java-Programmen wirksam vermieden werden.

Das obige ist der detaillierte Inhalt vonImplementierungsmethode der Thread-Synchronisation und des gegenseitigen Ausschlusses in der Java-Sprache. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!