std::mutex:: lock

Verrouille le mutex. Si un autre thread a déjà verrouillé le mutex, un appel à lock bloquera l'exécution jusqu'à ce que le verrou soit acquis.

Si lock est appelé par un thread qui possède déjà le mutex , le comportement est indéfini : par exemple, le programme peut se bloquer définitivement. Une implémentation capable de détecter cet usage non valide est encouragée à lever une std::system_error avec la condition d'erreur resource_deadlock_would_occur au lieu de se bloquer définitivement.

Les opérations de unlock() antérieures sur le même mutex synchronize-with (tel que défini dans std::memory_order ) cette opération.

Exceptions

Lance std::system_error en cas d'erreurs, y compris les erreurs du système d'exploitation sous-jacent qui empêcheraient lock de satisfaire ses spécifications. Le mutex n'est pas verrouillé en cas de levée d'une exception.

Notes

lock() n'est généralement pas appelé directement : std::unique_lock , std::scoped_lock , et std::lock_guard sont utilisés pour gérer le verrouillage exclusif.

Exemple

#include <chrono>
#include <iostream>
#include <mutex>
#include <thread>
int g_num = 0; // protected by g_num_mutex
std::mutex g_num_mutex;
void slow_increment(int id) 
{
    for (int i = 0; i < 3; ++i)
    {
        g_num_mutex.lock(); 
        ++g_num;
        // note, that the mutex also syncronizes the output
        std::cout << "id: " << id << ", g_num: " << g_num << '\n';
        g_num_mutex.unlock();
        std::this_thread::sleep_for(std::chrono::milliseconds(234));
    }
}
int main()
{
    std::thread t1{slow_increment, 0};
    std::thread t2{slow_increment, 1};
    t1.join();
    t2.join();
}

id: 0, g_num: 1
id: 1, g_num: 2
id: 1, g_num: 3
id: 0, g_num: 4
id: 0, g_num: 5
id: 1, g_num: 6

Voir aussi