Comment les verrous en lecture-écriture sont-ils utilisés dans la programmation simultanée en Java ?

Le verrouillage en lecture-écriture est un mécanisme de contrôle de concurrence qui permet à plusieurs threads de lire des ressources partagées simultanément, mais un seul thread peut écrire à la fois. Il est principalement utilisé pour les applications avec des charges de travail intensives en lecture et des écritures sporadiques. En Java, les verrous en lecture-écriture peuvent être implémentés à l'aide de l'interface java.util.concurrent.locks.ReadWriteLock, où les verrous en lecture autorisent l'accès en lecture et les verrous en écriture autorisent l'accès en écriture. Par exemple, dans un compteur partagé, plusieurs threads peuvent lire la valeur du compteur simultanément et le thread d'écriture doit acquérir un verrou en écriture pour mettre à jour le compteur, garantissant ainsi l'atomicité d'écriture et l'intégrité des données.

Le verrouillage en lecture-écriture en Java est utilisé pour la programmation simultanée

Introduction

Le verrouillage en lecture-écriture est un mécanisme de contrôle de concurrence qui permet à plusieurs threads de lire des ressources partagées simultanément, mais un seul thread peut écrire à la fois. heure Entrez les ressources partagées. Ceci est utile pour les applications avec des charges de travail intensives en lecture et des écritures occasionnelles.

Contrairement aux verrous mutex, les verrous en lecture-écriture permettent à plusieurs lecteurs d'accéder simultanément aux ressources partagées, tandis que les rédacteurs ont un accès exclusif à la ressource.

Utilisation de verrous en lecture-écriture en Java

L'interface java.util.concurrent.locks.ReadWriteLock en Java fournit la fonction de verrous en lecture-écriture. Il dispose de deux types de verrous :

• Verrouillage en lecture : Permet à un fil de discussion d'obtenir un accès en lecture à une ressource partagée.
• Write Lock : Permet à un fil d'obtenir un accès en écriture à une ressource partagée.

Voici un exemple d'utilisation d'un verrou en lecture-écriture :

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

Cas pratique

Considérons un compteur partagé où plusieurs threads lisent la valeur du compteur tandis qu'un seul thread la met à jour. Nous pouvons utiliser des verrous en lecture-écriture pour garantir l'intégrité des données lors d'un accès simultané.

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

Dans cet exemple, plusieurs threads de lecture peuvent lire la valeur du compteur simultanément, tandis que le thread d'écriture acquiert le verrou en écriture avant d'accéder au compteur. Cela garantit l’atomicité des opérations d’écriture et l’intégrité des données.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!