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

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


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


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

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



Return value



* 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


 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);
      std::cout << "The first few operations to file are done.\n";
      reader1 = std::thread(read, 3);

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)