std::shared_mutex:: lock

Erwirbt einen exklusiven Besitz des shared_mutex . Wenn ein anderer Thread eine exklusive Sperre oder eine gemeinsame Sperre auf demselben shared_mutex hält, wird ein Aufruf von lock die Ausführung blockieren, bis alle derartigen Sperren freigegeben sind. Während der shared_mutex im exklusiven Modus gesperrt ist, kann keine andere Sperre jeglicher Art ebenfalls gehalten werden.

Wenn lock von einem Thread aufgerufen wird, der das shared_mutex bereits in einem beliebigen Modus (exklusiv oder gemeinsam) besitzt, ist das Verhalten undefiniert. Ein vorheriger unlock() -Vorgang auf demselben Mutex synchronisiert-mit (wie definiert in std::memory_order ) diesem Vorgang.

Parameter

(keine)

Rückgabewert

(keine)

Ausnahmen

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() wird normalerweise nicht direkt aufgerufen: std::unique_lock , std::scoped_lock und std::lock_guard werden verwendet, um exklusive 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 const& 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); // besser als:
                                                                // smtx.lock();
                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
        {
            {
                // besser zu verwenden:
                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 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