Namespaces
Variants

std:: recursive_mutex

From cppreference.net
C++
Concurrency support library
Threads
(C++11)
(C++20)
(C++17) (C++17)
this_thread namespace
(C++11)
(C++11)
Cooperative cancellation
Mutual exclusion
(C++11)
recursive_mutex
(C++11)
(C++17)
Generic lock management
Condition variables
(C++11)
(C++11)
(C++11)
(C++11)
Semaphores
(C++20) (C++20)
Latches and Barriers
(C++20)
(C++20)
Futures
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Safe reclamation
Hazard pointers
(C++26)
(C++26)
(C++26)
Atomic types
(C++11)
(C++20)
(C++11)
Initialization of atomic types
(C++11) (deprecated in C++20)
(C++11) (deprecated in C++20)
(C++11)
Memory ordering
(C++11)
(C++11) (deprecated in C++26)
(C++11)
(C++11)
Free functions for atomic operations
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11) (C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++26) (C++26)
(C++26) (C++26)
(C++11)
(C++20) (C++20)
(C++20)
(C++20)
Free functions for atomic flags
(C++11) (C++11)
(C++11) (C++11)
(C++20) (C++20)
(C++20) (C++20)
(C++20)
(C++20)
std::recursive_mutex
Défini dans l'en-tête <mutex>
class recursive_mutex ;
(depuis C++11)

La classe recursive_mutex est un primitif de synchronisation qui peut être utilisé pour protéger les données partagées contre un accès simultané par plusieurs threads.

recursive_mutex offre une sémantique de propriété exclusive et récursive :

  • Un thread appelant possède un recursive_mutex pendant une période qui commence lorsqu'il appelle avec succès soit lock soit try_lock . Pendant cette période, le thread peut effectuer des appels supplémentaires à lock ou try_lock . La période de possession se termine lorsque le thread effectue un nombre correspondant d'appels à unlock .
  • Lorsqu'un thread possède un recursive_mutex , tous les autres threads seront bloqués (pour les appels à lock ) ou recevront une valeur de retour false (pour try_lock ) s'ils tentent de revendiquer la possession du recursive_mutex .
  • Le nombre maximum de fois qu'un recursive_mutex peut être verrouillé n'est pas spécifié, mais une fois ce nombre atteint, les appels à lock lanceront std::system_error et les appels à try_lock retourneront false .

Le comportement d'un programme est indéfini si un recursive_mutex est détruit alors qu'il est toujours détenu par un thread. La classe recursive_mutex satisfait toutes les exigences de Mutex et de StandardLayoutType .

Table des matières

Types membres

Type de membre Définition
native_handle_type ( optionnel* ) défini par l'implémentation

Fonctions membres

construit le mutex
(fonction membre publique)
détruit le mutex
(fonction membre publique)
operator=
[deleted]
non assignable par copie
(fonction membre publique)
Verrouillage
verrouille le mutex, bloque si le mutex n'est pas disponible
(fonction membre publique)
tente de verrouiller le mutex, retourne si le mutex n'est pas disponible
(fonction membre publique)
déverrouille le mutex
(fonction membre publique)
Gestionnaire natif
retourne l'objet gestionnaire natif défini par l'implémentation sous-jacente
(fonction membre publique)

Exemple

Un cas d'utilisation pour recursive_mutex est la protection de l'état partagé dans une classe dont les fonctions membres peuvent s'appeler mutuellement.

Exécuter ce code 
#include <iostream>
#include <mutex>
#include <thread>
class X
{
    std::recursive_mutex m;
    std::string shared;
public:
    void fun1()
    {
        std::lock_guard<std::recursive_mutex> lk(m);
        shared = "fun1";
        std::cout << "in fun1, shared variable is now " << shared << '\n';
    }
    void fun2()
    {
        std::lock_guard<std::recursive_mutex> lk(m);
        shared = "fun2";
        std::cout << "in fun2, shared variable is now " << shared << '\n';
        fun1(); // recursive lock becomes useful here
        std::cout << "back in fun2, shared variable is " << shared << '\n';
    }
};
int main() 
{
    X x;
    std::thread t1(&X::fun1, &x);
    std::thread t2(&X::fun2, &x);
    t1.join();
    t2.join();
}

Sortie possible : 

in fun1, shared variable is now fun1
in fun2, shared variable is now fun2
in fun1, shared variable is now fun1
back in fun2, shared variable is fun1

Voir aussi

(C++11)
fournit une fonction d'exclusion mutuelle de base
(classe)