Espaces de noms
Variantes

    std::mutex

    De cppreference.com
     
    C++
     
    Bibliothèque de support fil
    Threads
    Original:
    Threads
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    thread (C++11)
    this_thread espace de noms
    Original:
    this_thread namespace
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    get_id (C++11)
    yield (C++11)
    sleep_for (C++11)
    sleep_until (C++11)
    L'exclusion mutuelle
    Original:
    Mutual exclusion
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    mutex (C++11)
    timed_mutex (C++11)
    Gestion du verrouillage générique
    Original:
    Generic lock management
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    lock_guard (C++11)
    unique_lock (C++11)
    defer_lock_t
    try_to_lock_t
    adopt_lock_t    		 (C++11)
    (C++11)
    (C++11)
    lock (C++11)
    try_lock (C++11)
    defer_lock
    try_to_lock
    adopt_lock    		 (C++11)
    (C++11)
    (C++11)
    Les variables de condition
    Original:
    Condition variables
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    condition_variable (C++11)
    condition_variable_any (C++11)
    notify_all_at_thread_exit (C++11)
    cv_status (C++11)
    Futures
    Original:
    Futures
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    promise (C++11)
    future (C++11)
    shared_future (C++11)
    packaged_task (C++11)
    async (C++11)
    launch (C++11)
    future_status (C++11)
    future_error (C++11)
    future_category (C++11)
    future_errc (C++11)
     
    std::mutex
    Les fonctions membres
    Original:
    Member functions
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    mutex::mutex
    Verrouiller
    Original:
    Locking
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    mutex::lock
    mutex::try_lock
    mutex::unlock
    Handle natif
    Original:
    Native handle
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    mutex::native_handle
     
    <tbody> </tbody>
    Déclaré dans l'en-tête <mutex>
    class mutex;
    		 (depuis C++11)
    See More

    La classe mutex est une primitive de synchronisation qui peut être utilisée pour protéger des données partagées simultanément par plusieurs threads.

    Le mutex propose une sémantique de propriété exclusif et non-récursif :

    • Un thread appelant possède un mutex quand il réussit l'appel à lock ou try_lock et cela jusqu'à ce qu'il appelle unlock.
    • Quand un thread possède un mutex, tous les autres threads 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 un mutex avant d'appeler lock ou try_lock.

    Le comportement d'un programme n'est pas défini si un mutex est détruit alors qu'il est toujours détenu par un autre thread. La classe mutex n'est ni copiable ni déplaçable.

    Types de membres

    Type du membre Définition
    native_handle_type définie par l'implémentation

    Fonctions membres
    construit le mutex
    Original:
    constructs the mutex
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    (fonction membre publique) [edit]
    Verrouiller
    		verrouille le mutex, bloque si le mutex n'est pas disponible
    (fonction membre publique) [edit]
    essaie de verrouiller le mutex, retourne si le mutex n'est pas disponible
    Original:
    tries to lock the mutex, returns if the mutex is not available
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    (fonction membre publique) [edit]
    déverrouille le mutex
    Original:
    unlocks the mutex
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    (fonction membre publique) [edit]
    Handle natif
    Original:
    Native handle
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    retourne le handle de thread sous-jacente définie par l'implémentation
    Original:
    returns the underlying implementation-defined thread handle
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    (fonction membre publique) [edit]

    Exemple

    Cet exemple montre comment un mutex peut être utilisé pour protéger une map 

    #include <iostream>
#include <chrono>
#include <thread>
#include <mutex>
#include <map>
#include <string>

std::map<std::string, std::string> g_pages;
std::mutex g_pages_mutex;

void save_page(const std::string &url)
{
    // simulate a long page fetch
    std::this_thread::sleep_for(std::chrono::seconds(2));
    std::string result = "fake content";

    g_pages_mutex.lock();
    g_pages[url] = result;
    g_pages_mutex.unlock();
}

int main() 
{
    std::thread t1(save_page, "http://foo");
    std::thread t2(save_page, "http://bar");
    t1.join();
    t2.join();

    g_pages_mutex.lock();
    for (const auto &pair : g_pages) {
        std::cout << pair.first << " => " << pair.second << '\n';
    }
    g_pages_mutex.unlock();
}

    Résultat : 

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