CKTIS / Java
Lock — acquisition et libération explicites d’un verrou
L’interface java.util.concurrent.locks.Lock permet de contrôler explicitement le verrouillage. Découvrez la paire lock()/unlock(), le modèle sûr try/finally et un exemple où ReentrantLock protège un compteur partagé.
Version : Java SE 21; repository runtime, production runtime not attested
Syntaxe
Lock lock = new ReentrantLock();
lock.lock();
try {
// protected operations
} finally {
lock.unlock();
}java.util.concurrent.locks.Lock est une interface de verrouillage explicite ; ReentrantLock en est une implémentation qui assure l’exclusion mutuelle et permet au même thread de reprendre le verrou. Toutes les implémentations de Lock ne possèdent pas nécessairement ces propriétés.
Lock.lock() acquiert le verrou, en attendant si nécessaire ; Lock.unlock() le libère. Appelez lock.lock() avant try, puis lock.unlock() dans finally. Contrairement à synchronized, la libération n’est pas automatique. finally garantit la libération même si une exception se produit dans le code protégé.
Tous les accès concurrents à l’état protégé doivent respecter le même protocole de verrouillage. L’acquisition réussie du verrou par un thread qui ne le détient pas encore et sa libération complète réussie ont les mêmes effets de synchronisation de la mémoire que l’acquisition et la libération d’un moniteur, respectivement. Lock n’exige pas de tels effets pour les opérations qui échouent, ni pour les acquisitions réentrantes et les libérations correspondantes. synchronized (lock) ne remplace pas lock.lock().
Avec ReentrantLock, chaque acquisition doit avoir une libération correspondante ; si un thread qui ne détient pas le verrou appelle unlock(), une IllegalMonitorStateException est levée. L’interface propose aussi tryLock() et lockInterruptibly() pour d’autres stratégies d’attente.
L’exemple utilise un seul verrou partagé pour les deux opérations count++. Après les deux appels à join(), le programme affiche 2, quel que soit l’ordre d’exécution des threads. Périmètre de la documentation : Java SE 21 ; l’environnement d’exécution du dépôt et celui de production ne sont pas attestés.
Exemples
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Main {
private static final Lock lock = new ReentrantLock();
private static int count = 0;
private static void increment() {
lock.lock();
try {
count++;
} finally {
lock.unlock();
}
}
public static void main(String[] args) throws InterruptedException {
Thread first = new Thread(Main::increment);
Thread second = new Thread(Main::increment);
first.start();
second.start();
first.join();
second.join();
System.out.println(count);
}
}Résultat
2
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.