std::shared_timed_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 dans n'importe quel mode (partagé ou exclusif), le comportement est indéfini.

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.

Les mutex partagés ne prennent pas en charge la transition directe du mode de propriété partagée au mode de propriété exclusive : le verrou partagé doit être abandonné avec unlock_shared() avant que la propriété exclusive puisse être obtenue avec lock() . boost::upgrade_mutex peut être utilisé à cette fin.

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