std::shared_mutex

布满荆棘的人生 2023-06-06 03:58 8阅读 0赞

c++ 17 新出的具有独占模式和共享模式的锁。共享模式能够被 shared\_lock 占有。

std::shared\_mutex 是读写锁，提供两种访问权限的控制：共享性（shared）和排他性（exclusive）。通过lock/try\_lock获取排他性访问权限，通过lock\_shared/try\_lock\_shared获取共享性访问权限。这样的设置对于区分不同线程的读写操作特别有用。shared\_mutex是c++17中引入的，使用时需要注意编译器版本。

可以参考代码：

#include <iostream>
    #include <mutex>  // For std::unique_lock
    #include <shared_mutex>
    #include <thread>
     
    class ThreadSafeCounter {
     public:
      ThreadSafeCounter() = default;
     
      // Multiple threads/readers can read the counter's value at the same time.
      unsigned int get() const {
        std::shared_lock lock(mutex_);
        return value_;
      }
     
      // Only one thread/writer can increment/write the counter's value.
      void increment() {
        std::unique_lock lock(mutex_);
        value_++;
      }
     
      // Only one thread/writer can reset/write the counter's value.
      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; i++) {
          counter.increment();
          std::cout << std::this_thread::get_id() << ' ' << counter.get() << '\n';
     
          // Note: Writing to std::cout actually needs to be synchronized as well
          // by another std::mutex. This has been omitted to keep the example small.
        }
      };
     
      std::thread thread1(increment_and_print);
      std::thread thread2(increment_and_print);
     
      thread1.join();
      thread2.join();
    }
     
    // Explanation: The output below was generated on a single-core machine. When
    // thread1 starts, it enters the loop for the first time and calls increment()
    // followed by get(). However, before it can print the returned value to
    // std::cout, the scheduler puts thread1 to sleep and wakes up thread2, which
    // obviously has time enough to run all three loop iterations at once. Back to
    // thread1, still in the first loop iteration, it finally prints its local copy
    // of the counter's value, which is 1, to std::cout and then runs the remaining
    // two loop iterations. On a multi-core machine, none of the threads is put to
    // sleep and the output is more likely to be in ascending order.

可能的输出结果：  
123084176803584 2  
123084176803584 3  
123084176803584 4  
123084185655040 1  
123084185655040 5  
123084185655040 6

解释一下：  
std::cout << std::this\_thread::get\_id() << ’ ’ << counter.get() << ‘\\n’;  
这里的std::cout 是全局的变量，在加 shared\_lock 之后，能够保证是共享读，每次只能读到一个数据，另一个线程在等待分配mutex,所以输出不会乱码。

std::shared_mutex

发表评论取消回复

还没有评论，来说两句吧...

相关阅读