std:: mutex

La classe 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.

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

• Un thread appelant possède un mutex à partir du moment où il appelle avec succès soit lock soit try_lock jusqu'à ce qu'il appelle unlock .
• Lorsqu'un thread possède un mutex , tous les autres threads se bloqueront (pour les appels à lock ) ou recevront une valeur de retour false (pour try_lock ) s'ils tentent de revendiquer la propriété du mutex .
• Un thread appelant ne doit pas posséder le mutex avant d'appeler lock ou try_lock .

Le comportement d'un programme est indéfini si un mutex est détruit alors qu'il est encore détenu par des threads, ou si un thread se termine alors qu'il détient un mutex . La classe mutex satisfait à toutes les exigences de Mutex et de StandardLayoutType .

std::mutex n'est ni copiable ni déplaçable.

Types imbriqués

Fonctions membres

Notes

std::mutex n'est généralement pas accédé directement : std::unique_lock , std::lock_guard , ou std::scoped_lock (depuis C++17) gèrent le verrouillage de manière plus sûre face aux exceptions.

Exemple

#include <chrono>
#include <iostream>
#include <map>
#include <mutex>
#include <string>
#include <thread>
std::map<std::string, std::string> g_pages;
std::mutex g_pages_mutex;
void save_page(const std::string& url)
{
    // simuler un long chargement de page
    std::this_thread::sleep_for(std::chrono::seconds(2));
    std::string result = "fake content";
    std::lock_guard<std::mutex> guard(g_pages_mutex);
    g_pages[url] = result;
}
int main() 
{
    std::thread t1(save_page, "http://foo");
    std::thread t2(save_page, "http://bar");
    t1.join();
    t2.join();
    // accès sécurisé à g_pages sans verrou maintenant, car les threads sont joints
    for (const auto& [url, page] : g_pages)
        std::cout << url << " => " << page << '\n';
}

http://bar => fake content
http://foo => fake content

Voir aussi