std::shared_mutex:: lock_shared

Adquiere la propiedad compartida del mutex. Si otro hilo mantiene el mutex en propiedad exclusiva, una llamada a lock_shared bloqueará la ejecución hasta que se pueda adquirir la propiedad compartida.

Si lock_shared es llamado por un hilo que ya posee el mutex en cualquier modo (exclusivo o compartido), el comportamiento es indefinido.

Si más del máximo número definido por la implementación de propietarios compartidos ya ha bloqueado el mutex en modo compartido, lock_shared bloquea la ejecución hasta que el número de propietarios compartidos se reduzca. Se garantiza que el número máximo de propietarios es al menos 10000.

Una operación previa de unlock() en el mismo mutex synchronizes-with (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_shared() normalmente no se llama directamente: std::shared_lock se utiliza para gestionar el bloqueo compartido.

Ejemplo

#include <chrono>
#include <iostream>
#include <mutex>
#include <shared_mutex>
#include <syncstream>
#include <thread>
#include <vector>
std::mutex stream_mutx;
void print(auto 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);
                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
        {
            {
                smtx.lock_shared(); // es mejor usar: std::shared_lock lock(smtx);
                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