std::shared_lock<Mutex>::lock (3) - Linux Man Pages

std::shared_lock<Mutex>::lock: std::shared_lock<Mutex>::lock

NAME

std::shared_lock<Mutex>::lock - std::shared_lock<Mutex>::lock

Synopsis


void lock(); (since C++14)


Locks the associated mutex in shared mode. Effectively calls mutex()->lock_shared().

Parameters


(none)

Return value


(none)

Exceptions


* Any exceptions thrown by mutex()->lock_shared()


* If there is no associated mutex, std::system_error with an error code of std::errc::operation_not_permitted


* If the associated mutex is already locked by this shared_lock (that is, owns_lock returns true), std::system_error with an error code of std::errc::resource_deadlock_would_occur

Example


 This section is incomplete
 Reason: show a meaningful use of shared_lock::lock


// Run this code


  #include <iostream>
  #include <mutex>
  #include <string>
  #include <shared_mutex>
  #include <thread>


  std::string file = "Original content."; // Simulates a file
  std::mutex output_mutex; // mutex that protects output operations.
  std::shared_mutex file_mutex; // reader/writer mutex


  void read(int id)
  {
      std::string content;
      {
          std::shared_lock lock(file_mutex, std::defer_lock); // Do not lock it first.
          lock.lock(); // Lock it here.
          content = file;
      }
      std::lock_guard lock(output_mutex);
      std::cout << "Contents read by reader #" << id << ": " << content << '\n';
  }


  void write()
  {
      {
          std::lock_guard file_lock(file_mutex);
          file = "New content";
      }
      std::lock_guard output_lock(output_mutex);
      std::cout << "New content saved.\n";
  }


  int main()
  {
      std::cout << "Two readers reading from file.\n"
                << "A writer competes with them.\n";
      std::thread reader1(read, 1);
      std::thread reader2(read, 2);
      std::thread writer(write);
      reader1.join();
      reader2.join();
      writer.join();
      std::cout << "The first few operations to file are done.\n";
      reader1 = std::thread(read, 3);
      reader1.join();
  }

Possible output:


  Two readers reading from file.
  A writer competes with them.
  Contents read by reader #1: Original content.
  Contents read by reader #2: Original content.
  New content saved.
  The first few operations to file are done.
  Contents read by reader #3: New content

See also


         tries to lock the associated mutex
try_lock (public member function)
         unlocks the associated mutex
unlock (public member function)