FreeBSD Manual Pages
std::shared...lock_shared(3) C++ Standard Libary std::shared...lock_shared(3) NAME std::shared_mutex::lock_shared - std::shared_mutex::lock_shared Synopsis void lock_shared(); (since C++17) Acquires shared ownership of the mutex. If another thread is holding the mutex in exclusive ownership, a call to lock_shared will block execution un- til shared ownership can be acquired. If lock_shared is called by a thread that already owns the mutex in any mode (exclusive or shared), the behavior is undefined. If more than the implementation-defined maximum number of shared owners already locked the mutex in shared mode, lock_shared blocks execution until the number of shared owners is reduced. The maximum number of owners is guaranteed to be at least 10000. A prior unlock() operation on the same mutex synchronizes-with (as defined in std::memory_order) this operation. Parameters (none) Return value (none) Exceptions Throws std::system_error when errors occur, including errors from the underlying operating system that would prevent lock from meeting its specifica- tions. The mutex is not locked in the case of any exception being thrown. Notes lock_shared() is usually not called directly: std::shared_lock is used to manage shared locking. Example // Run this code #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() << " 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); 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 { { smtx.lock_shared(); // better to use: 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(); } Possible output: 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 See also lock locks the mutex, blocks if the mutex is not avail- able (public member function) tries to lock the mutex for shared ownership, re- turns if the mutex try_lock_shared is not available (public member function) unlock_shared unlocks the mutex (shared ownership) (public member function) http://cppreference.com 2024.06.10 std::shared...lock_shared(3)
NAME | Synopsis | Parameters | Return value | Exceptions | Notes | Example | Possible output: | See also
Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::shared_mutex::lock_shared&sektion=3&manpath=FreeBSD+Ports+15.1.quarterly>