std::shared_mutex:: lock

Acquiert la propriété exclusive du shared_mutex . Si un autre thread détient un verrou exclusif ou un verrou partagé sur le même shared_mutex , un appel à lock bloquera l'exécution jusqu'à ce que tous ces verrous soient libérés. Tant que le shared_mutex est verrouillé en mode exclusif, aucun autre verrou de quelque type que ce soit ne peut être détenu.

Si lock est appelé par un thread qui possède déjà le shared_mutex dans n'importe quel mode (exclusif ou partagé), le comportement est indéfini. Une opération unlock() antérieure sur le même mutex se synchronise-avec (tel que défini dans std::memory_order ) cette opération.

Paramètres

(aucun)

Valeur de retour

(aucun)

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 respecter 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 <shared_mutex>
#include <syncstream>
#include <thread>
#include <vector>
std::mutex stream_mutx;
void print(auto const& v)
{
    std::unique_lock<std::mutex> lock(stream_mutx);
    std::cout << std::this_thread::get_id() << " a vu : ";
    for (auto e : v)
        std::cout << e << ' ';
    std::cout << '\n';
}
int main()
{
    using namespace std::chrono_literals;
    constexpr int N_READERS = 5;
    constexpr int LAST = -999;
    std::shared_mutex smtx;
    int product = 0;
    auto writer = [&smtx, &product](int start, int end)
    {
        for (int i = start; i < end; ++i)
        {
            auto data = i;
            {
                std::unique_lock<std::shared_mutex> lock(smtx); // mieux que :
                                                                // smtx.lock();
                product = data;
            }
            std::this_thread::sleep_for(3ms);
        }
        smtx.lock(); // verrouillage manuel
        product = LAST;
        smtx.unlock();
    };
    auto reader = [&smtx, &product]
    {
        int data = 0;
        std::vector<int> seen;
        do
        {
            {
                // mieux d'utiliser :
                std::shared_lock lock(smtx); // smtx.lock_shared();
                data = product;
            }                                // smtx.unlock_shared();
            seen.push_back(data);
            std::this_thread::sleep_for(2ms);
        }
        while (data != LAST);
        print(seen);
    };
    std::vector<std::thread> threads;
    threads.emplace_back(writer, 1, 13);
    threads.emplace_back(writer, 42, 52);
    for (int i = 0; i < N_READERS; ++i)
        threads.emplace_back(reader);
    for (auto&& t : threads)
        t.join();
}

127755840 saw: 43 3 3 4 46 5 6 7 7 8 9 51 10 11 11 12 -999
144541248 saw: 2 44 3 4 46 5 6 7 7 8 9 51 10 11 11 12 -999
110970432 saw: 42 2 3 45 4 5 47 6 7 8 8 9 10 11 11 12 -999
119363136 saw: 42 2 3 4 46 5 6 7 7 8 9 9 10 11 11 12 12 -999
136148544 saw: 2 44 3 4 46 5 6 48 7 8 9 51 10 11 11 12 12 -999

Voir aussi