Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

ReadWriteLock — verrous de lecture et d’écriture distincts

ReadWriteLock fournit des verrous de lecture et d’écriture associés : plusieurs lecteurs peuvent partager l’accès, tandis que l’écriture exige un accès exclusif. Découvrez readLock() et writeLock(), la visibilité des modifications et la libération sûre des verrous.

Version : Java SE 21; repository runtime, production runtime not attested

Syntaxe

ReadWriteLock rw = new ReentrantReadWriteLock();
Lock read = rw.readLock();
Lock write = rw.writeLock();
read.lock();
try {
    // Read protected state.
} finally {
    read.unlock();
}
write.lock();
try {
    // Modify protected state.
} finally {
    write.unlock();
}

java.util.concurrent.locks.ReadWriteLock est une interface représentant une paire de verrous associés. ReadWriteLock.readLock() renvoie un Lock pour la lecture et ReadWriteLock.writeLock() un verrou pour l’écriture ; appeler ces méthodes ne permet pas d’acquérir un verrou. Plusieurs lecteurs peuvent travailler simultanément en l’absence de rédacteur ; l’écriture est exclusive.

Appelez lock() sur l’objet renvoyé avant la section protégée, puis unlock() dans finally, en plaçant lock() avant try. Tous les accès à l’état protégé doivent respecter le même protocole. Ne modifiez pas l’état sous le verrou de lecture. L’acquisition réussie du verrou de lecture rend visibles les modifications publiées par une libération antérieure du verrou d’écriture associé.

Une implémentation courante est ReentrantReadWriteLock. Son mode par défaut ne garantit pas un ordre équitable. N’essayez pas d’acquérir le verrou d’écriture tout en détenant encore le verrou de lecture : cette implémentation ne prend pas en charge cette promotion. Après avoir libéré le verrou de lecture et acquis celui d’écriture, vérifiez à nouveau la condition, car l’état a pu changer. Ces règles propres à l’implémentation ne constituent pas des garanties supplémentaires de l’interface.

Cette approche peut être envisagée lorsque les lectures sont fréquentes et les écritures moins fréquentes, mais le surcoût peut annuler les avantages ; mesurez les performances. L’exemple protège value et affiche 42 de manière déterministe. Les appels séquentiels dans main montrent comment utiliser l’API, et non une exécution parallèle ni la correction pour chaque entrelacement possible des threads.

Exemples

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Main {
    private final ReadWriteLock rw = new ReentrantReadWriteLock();
    private int value;

    public int get() {
        Lock read = rw.readLock();
        read.lock();
        try {
            return value;
        } finally {
            read.unlock();
        }
    }

    public void set(int next) {
        Lock write = rw.writeLock();
        write.lock();
        try {
            value = next;
        } finally {
            write.unlock();
        }
    }

    public static void main(String[] args) {
        Main cell = new Main();
        cell.set(42);
        System.out.println(cell.get());
    }
}

Résultat

42

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources