Wie werden Lese-/Schreibsperren bei der gleichzeitigen Programmierung in Java verwendet?

Die Lese-/Schreibsperre ist ein Mechanismus zur Steuerung der Parallelität, der es mehreren Threads ermöglicht, gemeinsam genutzte Ressourcen gleichzeitig zu lesen, aber jeweils nur ein Thread schreiben kann. Es wird hauptsächlich für Anwendungen mit leseintensiven Arbeitslasten und sporadischen Schreibvorgängen verwendet. In Java können Lese-/Schreibsperren über die Schnittstelle java.util.concurrent.locks.ReadWriteLock implementiert werden, wobei Lesesperren Lesezugriff und Schreibsperren Schreibzugriff ermöglichen. In einem gemeinsam genutzten Zähler können beispielsweise mehrere Threads den Zählerwert gleichzeitig lesen, und der schreibende Thread muss eine Schreibsperre erwerben, um den Zähler zu aktualisieren, um die Atomizität des Schreibens und die Datenintegrität sicherzustellen.

Lese-/Schreibsperre in Java wird für die gleichzeitige Programmierung verwendet Zeit Geben Sie gemeinsam genutzte Ressourcen ein. Dies ist nützlich für Anwendungen mit leseintensiven Arbeitslasten und gelegentlichen Schreibvorgängen.

Im Gegensatz zu Mutex-Sperren ermöglichen Lese-/Schreibsperren mehreren Lesern den gleichzeitigen Zugriff auf gemeinsam genutzte Ressourcen, während Autoren exklusiven Zugriff auf die Ressource haben.

Verwenden von Lese-/Schreibsperren in Java

Die Schnittstelle

java.util.concurrent.locks.ReadWriteLock

in Java bietet die Funktion von Lese-/Schreibsperren. Es gibt zwei Arten von Sperren:

Lesesperre: Ermöglicht einem Thread, Lesezugriff auf eine freigegebene Ressource zu erhalten.

Schreibsperre:
• Ermöglicht einem Thread, Schreibzugriff auf eine freigegebene Ressource zu erhalten.
Hier ist ein Beispiel für die Verwendung einer Lese-/Schreibsperre:

• import java.util.concurrent.locks.ReentrantReadWriteLock;
  
  public class SharedResource {
  
      private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
      private int value;
  
      public void read() {
          lock.readLock().lock();
          try {
              // 读取共享资源
              System.out.println("Reading: " + value);
          } finally {
              lock.readLock().unlock();
          }
      }
  
      public void write(int newValue) {
          lock.writeLock().lock();
          try {
              // 写入共享资源
              value = newValue;
              System.out.println("Writing: " + value);
          } finally {
              lock.writeLock().unlock();
          }
      }
  }

  Praktischer Fall

Stellen Sie sich einen gemeinsamen Zähler vor, bei dem mehrere Threads den Zählerwert lesen, während nur ein Thread ihn aktualisiert. Wir können Lese-/Schreibsperren verwenden, um die Datenintegrität beim gleichzeitigen Zugriff sicherzustellen.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CounterExample {

    private final SharedResource counter = new SharedResource();
    private final ExecutorService executor = Executors.newFixedThreadPool(10);

    public void run() {
        // 创建 10 个读取线程
        for (int i = 0; i < 10; i++) {
            executor.submit(counter::read);
        }

        // 模拟写入线程
        for (int i = 0; i < 100; i++) {
            executor.submit(() -> counter.write(i));
        }

        executor.shutdown();
    }

    public static void main(String[] args) {
        new CounterExample().run();
    }
}

In diesem Beispiel können mehrere Lesethreads den Zählerwert gleichzeitig lesen, während der Schreibthread die Schreibsperre erhält, bevor er auf den Zähler zugreift. Dies gewährleistet die Atomizität von Schreibvorgängen und die Datenintegrität.

Das obige ist der detaillierte Inhalt vonWie werden Lese-/Schreibsperren bei der gleichzeitigen Programmierung in Java verwendet?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!