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

CKTIS / Java

Méthodes de ReentrantLock : acquisition, réentrance et conditions

Distinguez `lock()`, qui peut bloquer, des deux surcharges de `tryLock()`. Associez chaque acquisition réussie à `unlock()` et utilisez des conditions distinctes sur un même verrou.

Version : Java SE 21

Syntaxe

// Java SE 21 — instance methods of java.util.concurrent.locks.ReentrantLock
public void lock()
public void unlock()
public boolean tryLock()
public boolean tryLock(long timeout, java.util.concurrent.TimeUnit unit) throws InterruptedException
public java.util.concurrent.locks.Condition newCondition()
public int getHoldCount()

Dans Java SE 21, java.util.concurrent.locks.ReentrantLock est un verrou d’exclusion mutuelle réentrant. lock() attend si un autre thread détient le verrou ; une interruption ne met pas fin à cette attente. Le propriétaire peut reprendre le même verrou sans attendre. getHoldCount() compte les acquisitions non compensées du thread courant, et non les threads en attente ; 0 ne signifie pas que le verrou est libre.

unlock() décrémente le compteur et ne libère le verrou qu’à 0. Un thread qui ne détient pas le verrou reçoit une IllegalMonitorStateException. Ouvrez un bloc try immédiatement après chaque acquisition réussie et placez l’appel correspondant à unlock() dans finally. Ne libérez pas le verrou au titre d’une tentative qui échoue ou déclenche une exception. Si le code a besoin des deux verrous, prenez-les toujours dans le même ordre, par exemple gateLock avant orderLock, et libérez-les dans l’ordre inverse.

tryLock() n’attend pas : il renvoie false si un autre thread détient le verrou, ou true en cas d’acquisition, y compris par réentrance. Il peut devancer les threads en attente même sur un verrou équitable. tryLock(timeout, unit) respecte la politique d’équité si elle est activée, attend au plus la durée indiquée (timeout <= 0 signifie qu’il n’attend pas) et renvoie false s’il n’obtient pas le verrou dans ce délai. Une interruption à l’entrée ou pendant l’acquisition déclenche InterruptedException et efface l’état d’interruption ; unit == null est invalide et déclenche NullPointerException.

Chaque appel à newCondition() crée un objet Condition distinct lié au même verrou. Dans un tampon à une place, notEmpty sert aux consommateurs et notFull aux producteurs. Appeler signal() sans détenir ce verrou déclenche IllegalMonitorStateException. await() vérifie d’abord l’état d’interruption du thread courant. Si le thread est déjà interrompu, await() efface cet état et déclenche InterruptedException avant de vérifier si le thread détient le verrou, sans libérer celui-ci. Dans le cas contraire, await() déclenche IllegalMonitorStateException si le thread ne détient pas le verrou. Si l’attente commence, await() libère atomiquement le verrou, puis le reprend avec le compteur d’origine avant la fin de l’appel. Vérifiez l’état dans une boucle while, car des réveils intempestifs sont possibles. Signalez après avoir modifié l’état, en tenant encore le verrou ; signal() ne le libère pas.

Exemples

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Main {
    private static final class Slot {
        private final ReentrantLock lock = new ReentrantLock();
        private final Condition notEmpty = lock.newCondition();
        private final Condition notFull = lock.newCondition();
        private Integer value;

        void put(int item) throws InterruptedException {
            lock.lock();
            try {
                while (value != null) {
                    notFull.await();
                }
                value = item;
                notEmpty.signal();
            } finally {
                lock.unlock();
            }
        }

        int take() throws InterruptedException {
            lock.lock();
            try {
                while (value == null) {
                    notEmpty.await();
                }
                int item = value;
                value = null;
                notFull.signal();
                return item;
            } finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ReentrantLock gateLock = new ReentrantLock();
        ReentrantLock orderLock = new ReentrantLock(true);

        System.out.println(orderLock.getHoldCount());
        orderLock.lock();
        try {
            orderLock.lock();
            try {
                System.out.println(orderLock.getHoldCount());
            } finally {
                orderLock.unlock();
            }
            System.out.println(orderLock.getHoldCount());
            if (orderLock.tryLock()) {
                try {
                    System.out.println(orderLock.getHoldCount());
                } finally {
                    orderLock.unlock();
                }
            }
            System.out.println(orderLock.getHoldCount());
        } finally {
            orderLock.unlock();
        }
        System.out.println(orderLock.getHoldCount());

        gateLock.lock();
        try {
            for (int attempt = 1; attempt <= 2; attempt++) {
                if (!orderLock.tryLock(10, TimeUnit.MILLISECONDS)) {
                    System.out.println("timed " + attempt + ": timeout");
                    continue;
                }
                try {
                    System.out.println("timed " + attempt + ": acquired");
                } finally {
                    orderLock.unlock();
                }
            }
        } finally {
            gateLock.unlock();
        }

        Slot slot = new Slot();
        slot.put(42);
        System.out.println("slot: " + slot.take());
    }
}

Résultat

0
2
1
2
1
0
timed 1: acquired
timed 2: acquired
slot: 42

Deux appels à `lock()` donnent le premier `2` après le `0` initial. Un `unlock()` laisse `1`, puis le `tryLock()` immédiat du propriétaire rétablit `2`. Les deux libérations restantes donnent `1` et `0`. Les deux tentatives avec délai visent le même `orderLock` et réussissent sans contention. `put(42)` et `take()` utilisent des conditions distinctes du même verrou du tampon ; aucune des deux opérations n’attend ici.

Leçons associées

  • Java · Leçon 30 · Avancé · Version : 2
  • Java · Leçon 54 · Intermédiaire · Version : 2
  • Java · Leçon 58 · Intermédiaire · Version : 2

Sources