std::shared_mutex:: lock_shared

Erwirbt gemeinsamen Besitz des Mutex. Wenn ein anderer Thread den Mutex im exklusiven Besitz hält, wird ein Aufruf von lock_shared die Ausführung blockieren, bis gemeinsamer Besitz erworben werden kann.

Wenn lock_shared von einem Thread aufgerufen wird, der den mutex bereits in einem beliebigen Modus (exklusiv oder gemeinsam) besitzt, ist das Verhalten undefiniert.

Wenn bereits mehr als die implementierungsdefinierte maximale Anzahl von gemeinsam genutzten Besitzern den Mutex im gemeinsam genutzten Modus gesperrt hat, lock_shared blockiert die Ausführung, bis die Anzahl der gemeinsam genutzten Besitzer reduziert wird. Die maximale Anzahl von Besitzern ist garantiert mindestens 10000.

Ein vorheriger unlock() -Vorgang auf demselben Mutex synchronisiert-mit (wie definiert in std::memory_order ) diesem Vorgang.

Parameter

(keine)

Rückgabewert

(keine)

Exceptions

Wirft std::system_error bei Auftreten von Fehlern, einschließlich Fehlern des zugrundeliegenden Betriebssystems, die verhindern würden, dass lock seine Spezifikationen erfüllen kann. Das Mutex wird im Falle einer ausgelösten Ausnahme nicht gesperrt.

Hinweise

lock_shared() wird normalerweise nicht direkt aufgerufen: std::shared_lock wird verwendet, um gemeinsames Sperren zu verwalten.

Beispiel

#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() << " sah: ";
    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(); // manuell sperren
        product = LAST;
        smtx.unlock();
    };
    auto reader = [&smtx, &product]()
    {
        int data = 0;
        std::vector<int> seen;
        do
        {
            {
                smtx.lock_shared(); // besser zu verwenden: 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 sah: 43 3 3 4 46 5 6 7 7 8 9 51 10 11 11 12 -999
144541248 sah: 2 44 3 4 46 5 6 7 7 8 9 51 10 11 11 12 -999
110970432 sah: 42 2 3 45 4 5 47 6 7 8 8 9 10 11 11 12 -999
119363136 sah: 42 2 3 4 46 5 6 7 7 8 9 9 10 11 11 12 12 -999
136148544 sah: 2 44 3 4 46 5 6 48 7 8 9 51 10 11 11 12 12 -999

Siehe auch