std::shared_mutex:: lock

Adquiere la propiedad exclusiva del shared_mutex . Si otro hilo mantiene un bloqueo exclusivo o un bloqueo compartido en el mismo shared_mutex , una llamada a lock bloqueará la ejecución hasta que todos estos bloqueos sean liberados. Mientras el shared_mutex esté bloqueado en modo exclusivo, ningún otro tipo de bloqueo puede mantenerse simultáneamente.

Si lock es llamado por un hilo que ya posee el shared_mutex en cualquier modo (exclusivo o compartido), el comportamiento es indefinido. Una operación previa de unlock() en el mismo mutex sincroniza-con (como se define en std::memory_order ) esta operación.

Parámetros

(ninguno)

Valor de retorno

(ninguno)

Excepciones

Lanza std::system_error cuando ocurren errores, incluyendo errores del sistema operativo subyacente que impedirían que lock cumpla con sus especificaciones. El mutex no queda bloqueado en caso de que se lance cualquier excepción.

Notas

lock() normalmente no se llama directamente: std::unique_lock , std::scoped_lock , y std::lock_guard se utilizan para gestionar el bloqueo exclusivo.

Ejemplo

#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() << " vio: ";
    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); // mejor que:
                                                                // smtx.lock();
                product = data;
            }
            std::this_thread::sleep_for(3ms);
        }
        smtx.lock(); // bloquear manualmente
        product = LAST;
        smtx.unlock();
    };
    auto reader = [&smtx, &product]
    {
        int data = 0;
        std::vector<int> seen;
        do
        {
            {
                // es mejor usar:
                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 vio: 43 3 3 4 46 5 6 7 7 8 9 51 10 11 11 12 -999
144541248 vio: 2 44 3 4 46 5 6 7 7 8 9 51 10 11 11 12 -999
110970432 vio: 42 2 3 45 4 5 47 6 7 8 8 9 10 11 11 12 -999
119363136 vio: 42 2 3 4 46 5 6 7 7 8 9 9 10 11 11 12 12 -999
136148544 vio: 2 44 3 4 46 5 6 48 7 8 9 51 10 11 11 12 12 -999

Véase también