Shulou(Shulou.com)06/01 Report--

Most people do not understand the knowledge of this article "how to use C++ 's std::shared_mutex read-write lock", so the editor summarizes the following contents, detailed contents, clear steps, and has a certain reference value. I hope you can get something after reading this article. Let's take a look at this "C++ std::shared_mutex read-write lock how to use" article.

0. Preface

Read-write lock divides visitors to shared resources into readers and writers. readers only read and access shared resources, while writers need to write to shared resources. Starting with Clipper 17, the standard library provides the shared_mutex class (until then, you can use boost's shared_mutex class or system-related api). Unlike other mutexes that facilitate exclusive access, shared_mutex has two access levels:

Sharing: multiple threads can share ownership of the same mutex (such as cooperating with shared_lock)

Exclusive: only one thread can hold mutexes (such as with lock_guard, unique_lock).

Shared_mutex is usually used when multiple reader threads can access the same resource at the same time without causing data contention, but only one writer thread can access it.

1. Get to know std::shared_mutex

By looking at the interface of the class, you can see that the class not only provides a mutex locking interface, but also provides a shared locking interface.

Lock () locks the mutex. If another thread has locked the mutex, the call to lock () blocks execution until the lock is acquired. Mutex locks can be managed with std::lock_guard and std::unique_lock.

Shared_lock () acquires mutually exclusive shared ownership. If another thread maintains mutual exclusion with exclusive ownership, the call to shared_lock () blocks execution until shared ownership can be obtained. If shared_lock () has been called by a thread that owns the mutex in any mode (exclusive or shared), the behavior is not defined. If more than the maximum number of share owners defined by the implementation has locked the mutex in shared mode, shared_lock () blocks execution until the number of share owners decreases. The maximum number of owners is guaranteed to be at least 10000. Shared locks can be managed with std::shared_lock.

two。 Example demonstration

Here is an example borrowed directly from the online manual:

# include / / std::unique_lock#include # include # include class ThreadSafeCounter {public: ThreadSafeCounter () = default; / / multiple threads / readers can read the value of the counter at the same time. Unsigned int get () const {std::shared_lock lock (mutex_); return value_;} / / only one thread / writer can increment / write the value of the thread. Void increment () {std::unique_lock lock (mutex_); value_++;} / / only one thread / writer can reset / write the value of the thread. Void reset () {std::unique_lock lock (mutex_); value_ = 0;} private: mutable std::shared_mutex mutex_; unsigned int value_ = 0;}; int main () {ThreadSafeCounter counter; auto increment_and_print = [& counter] () {for (int I = 0; I < 3; iTunes +) {counter.increment (); std::cout

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.