std::shared_mutex::lock
| void lock(); |
(seit C++17) | |
Erwirbt ein exklusives Eigentum am shared_mutex. Wenn ein anderer Thread einen exklusiven Lock oder einen Shared-Lock auf demselben shared_mutex hält, blockiert ein Aufruf von lock die Ausführung, bis alle solchen Locks freigegeben sind. Während shared_mutex im exklusiven Modus gesperrt ist, kann kein anderer Lock jeglicher Art gehalten werden.
Wenn lock von einem Thread aufgerufen wird, der den shared_mutex bereits in irgendeinem Modus (exklusiv oder Shared) besitzt, ist das Verhalten undefiniert. Eine vorherige unlock()-Operation auf demselben Mutex synchronisiert-mit (wie in std::memory_order definiert) diese Operation.
Inhalt |
[bearbeiten] Parameter
(keine)
[bearbeiten] Rückgabewert
(keine)
[bearbeiten] Ausnahmen
Wirft std::system_error bei Fehlern, einschließlich Fehlern des zugrunde liegenden Betriebssystems, die verhindern, dass lock seine Spezifikationen erfüllt. Die Mutex ist im Falle einer geworfenen Ausnahme nicht gesperrt.
[bearbeiten] Hinweise
lock() wird normalerweise nicht direkt aufgerufen: std::unique_lock, std::scoped_lock und std::lock_guard werden zur Verwaltung exklusiver Sperren verwendet.
[bearbeiten] 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() << " saw: "; 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); // better than: // smtx.lock(); product = data; } std::this_thread::sleep_for(3ms); } smtx.lock(); // lock manually product = LAST; smtx.unlock(); }; auto reader = [&smtx, &product] { int data = 0; std::vector<int> seen; do { { // better to use: 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(); }
Mögliche Ausgabe
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
[bearbeiten] Siehe auch
| versucht, den Mutex zu sperren, kehrt zurück, wenn der Mutex nicht verfügbar ist (public member function) | |
| entsperrt den Mutex (public member function) | |
| sperrt den Mutex für gemeinsamen Besitz, blockiert, wenn der Mutex nicht verfügbar ist (public member function) |
