CKTIS / C++
std::recursive_mutex — verrouillage répété par le même thread
std::recursive_mutex permet au même thread d’acquérir plusieurs fois le même mutex. Les autres threads ne peuvent l’acquérir qu’après la libération de tous les niveaux de possession. Chaque acquisition réussie nécessite un déverrouillage distinct.
Version : C++23; repository compiler flag, production runtime not attested
Syntaxe
#include <mutex>
std::recursive_mutex m;
std::lock_guard<std::recursive_mutex> guard(m);std::recursive_mutex, disponible dans <mutex>, assure une possession exclusive et permet à son propriétaire de l’acquérir plusieurs fois. Contrairement à std::mutex, il permet au même thread de rappeler lock() ou d’appeler avec succès try_lock() alors qu’il possède déjà le mutex. Cela ne signifie pas que plusieurs threads se partagent sa possession.
Chaque acquisition réussie augmente le niveau d’imbrication et nécessite un appel à unlock(). Tant que le propriétaire n’a pas libéré tous les niveaux, le lock() d’un autre thread bloque et son try_lock() renvoie false. Le nombre maximal de niveaux n’est pas spécifié : une fois cette limite atteinte, try_lock() échoue et lock() lève std::system_error.
Utilisez std::lock_guard<std::recursive_mutex> pour associer chaque acquisition à une libération à la sortie de la portée, y compris lors d’une sortie due à une exception. Le mutex doit vivre plus longtemps que ses guards. Détruire un mutex qui est possédé, ou terminer un thread qui le possède encore, entraîne un comportement indéfini.
Dans l’exemple, increment_twice() conserve le verrou externe, et chaque appel à increment() ajoute temporairement un niveau supplémentaire. Les guards libèrent les niveaux dans l’ordre inverse. Un seul thread suffit à montrer les acquisitions répétées et un résultat déterministe ; l’exemple ne teste pas la contention entre threads. Un mutex récursif ne remplace pas une stratégie réfléchie de verrouillage de plusieurs mutex.
Exemples
#include <iostream>
#include <mutex>
class Counter {
std::recursive_mutex mutex_;
int value_ = 0;
public:
void increment() {
std::lock_guard<std::recursive_mutex> guard(mutex_);
++value_;
}
int increment_twice() {
std::lock_guard<std::recursive_mutex> guard(mutex_);
increment();
increment();
return value_;
}
};
int main() {
Counter counter;
std::cout << counter.increment_twice() << '\n';
}
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.