CKTIS / C++
std::unique_lock — gestion flexible des verrous de mutex
std::unique_lock est un objet RAII déplaçable mais non copiable de <mutex>, qui gère la propriété d’un verrou de mutex. Il permet de différer le verrouillage, de déverrouiller avant la sortie de portée et de verrouiller à nouveau. Son destructeur déverrouille le mutex uniquement si l’objet possède encore le verrou.
Version : C++23; repository compiler flag, production runtime not attested
Syntaxe
#include <mutex>
std::unique_lock<Mutex> lock(mutex);
std::unique_lock<Mutex> lock(mutex, std::defer_lock);std::unique_lock<Mutex> de <mutex> gère la propriété du verrou, et non la durée de vie du mutex. Il applique RAII : si l’objet possède le verrou, son destructeur appelle unlock() sur le mutex, y compris lorsqu’une exception entraîne la sortie de portée. Le mutex doit rester valide tant que l’objet lui est associé. L’objet peut être déplacé, mais pas copié.
La construction avec un mutex seul appelle son lock(). Le marqueur std::defer_lock établit une association sans verrouiller ; std::try_to_lock effectue une tentative non bloquante, dont vous pouvez vérifier le résultat avec owns_lock() ou par conversion en bool. std::adopt_lock exige que le thread courant possède déjà un verrou exclusif sur le mutex ; ce n’est pas un moyen d’acquérir ce verrou.
lock() et unlock() permettent de modifier l’état avant la sortie de portée. N’appelez pas lock() lorsque l’objet possède déjà le verrou, ni unlock() lorsqu’il ne le possède pas. Mutex doit satisfaire aux exigences de BasicLockable ; les opérations d’essai de verrouillage exigent aussi Lockable, tandis que try_lock_for() et try_lock_until() exigent TimedLockable. L’utilisation de std::unique_lock n’ajoute pas à elle seule la prise en charge des délais à un mutex.
Ne confondez pas release() et unlock() : release() renvoie le pointeur vers le mutex et supprime l’association, mais ne déverrouille pas le mutex. La responsabilité de tout déverrouillage nécessaire incombe alors au code appelant. L’exemple montre un verrouillage différé, un déverrouillage explicite, puis un nouveau verrouillage, après quoi le destructeur libère le verrou. Un seul thread rend la sortie déterministe ; l’exemple ne montre pas de contention entre threads.
Exemples
#include <iostream>
#include <mutex>
int main() {
std::mutex mutex;
int value = 0;
{
std::unique_lock<std::mutex> lock(mutex, std::defer_lock);
std::cout << std::boolalpha << lock.owns_lock() << '\n';
lock.lock();
++value;
std::cout << lock.owns_lock() << ' ' << value << '\n';
lock.unlock();
std::cout << lock.owns_lock() << '\n';
lock.lock();
}
std::cout << value << '\n';
}
Résultat
false true 1 false 1
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.