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

CKTIS / Java

Verrou de lecture-écriture : readLock(), writeLock(), lock() et unlock()

Plusieurs threads peuvent lire des données partagées en même temps, mais l’écriture exige un accès exclusif. Choisir un verrou ne revient pas à l’acquérir.

Version : Java SE 21

Syntaxe

// java.util.concurrent.locks.ReadWriteLock
Lock readLock();
Lock writeLock();

// java.util.concurrent.locks.Lock
void lock();
void unlock();

Dans Java SE 21, ReadWriteLock et Lock sont des interfaces du paquet java.util.concurrent.locks. readLock() et writeLock() renvoient les objets Lock associés sans acquérir les verrous. Utilisez une même instance de ReadWriteLock pour protéger l’état partagé : le verrou de lecture pour les opérations qui ne modifient rien, celui d’écriture pour les modifications. Plusieurs threads peuvent détenir le verrou de lecture simultanément. Tant qu’un thread détient le verrou d’écriture, aucun autre ne peut acquérir l’un ou l’autre verrou.

lock() et unlock() ne prennent aucun argument et ont pour type de retour void. Appelez lock() avant le bloc try : si le verrou est indisponible, le thread attend de l’acquérir. Appelez unlock() sur le même Lock dans finally pour le libérer même si le code protégé lève une exception. Le tryLock() sans argument de l’exemple n’attend pas : il renvoie true s’il a acquis le verrou, sinon false. Ne libérez le verrou qu’après une acquisition réussie.

Après la libération du verrou d’écriture, un thread qui acquiert ensuite le verrou de lecture associé voit les modifications faites sous le verrou d’écriture. Les verrous ne protègent pas les accès à l’état qui les contournent.

Avec ReentrantReadWriteLock, le thread doit faire correspondre chaque acquisition à un unlock(). Libérer un verrou qu’il ne détient pas lève IllegalMonitorStateException. Ne tentez pas d’acquérir le verrou d’écriture en détenant seulement celui de lecture : lock() ne rendra pas la main. Libérez le verrou de lecture, acquérez celui d’écriture puis vérifiez de nouveau l’état, qui a pu changer entre-temps. Dans l’autre sens, vous pouvez acquérir le verrou de lecture tout en détenant celui d’écriture, puis libérer ce dernier.

Exemples

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

public class ReadWriteLockDemo {
    private final ReadWriteLock rw = new ReentrantReadWriteLock();
    private final Lock read = rw.readLock();
    private final Lock write = rw.writeLock();
    private int value = 0;

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        new ReadWriteLockDemo().run();
    }

    private void run() throws InterruptedException, ExecutionException {
        read.lock();
        try {
            System.out.println("read lock held: " + probeFromAnotherThread());
        } finally {
            read.unlock();
        }

        write.lock();
        try {
            value = 10;
            System.out.println("write lock held: " + probeFromAnotherThread());
        } finally {
            write.unlock();
        }

        int snapshot;
        read.lock();
        try {
            snapshot = value;
        } finally {
            read.unlock();
        }
        System.out.println("read after write: " + snapshot);
    }

    private String probeFromAnotherThread() throws InterruptedException, ExecutionException {
        FutureTask<String> probe = new FutureTask<>(() -> {
            String snapshot = "blocked";
            if (read.tryLock()) {
                try {
                    snapshot = Integer.toString(value);
                } finally {
                    read.unlock();
                }
            }
            return "reader=" + snapshot + ", writer=" + canAcquireNow(write);
        });
        new Thread(probe).start();
        return probe.get();
    }

    private static boolean canAcquireNow(Lock lock) {
        if (!lock.tryLock()) {
            return false;
        }
        try {
            return true;
        } finally {
            lock.unlock();
        }
    }
}

Résultat

read lock held: reader=0, writer=false
write lock held: reader=blocked, writer=false
read after write: 10

Pendant que le thread principal détient le verrou de lecture, un second thread lit `0` sans pouvoir acquérir le verrou d’écriture. Après que le thread principal a inscrit `10`, et tant qu’il détient le verrou d’écriture, les deux tentatives du second thread échouent. Une fois ce verrou libéré, une lecture protégée donne `10`. `FutureTask.get()` impose cet ordre sans temporisation.

Leçons associées

  • Java · Leçon 29 · Avancé · Version : 2

Sources