Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help 
std::shared_lock::lock(3)     C++ Standard Libary    std::shared_lock::lock(3)

NAME
       std::shared_lock::lock -	std::shared_lock::lock

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

	  Locks	 the  associated  mutex	 in shared mode. Effectively calls mu-
       tex()->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_content(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_content()
	{
	    {
		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_content, 1};
	    std::thread	reader2{read_content, 2};
	    std::thread	writer{write_content};
	    reader1.join();
	    reader2.join();
	    writer.join();
	    std::cout << "The first few	operations to file are done.\n";
	    reader1 = std::thread{read_content,	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
	  try_lock tries to lock the associated	mutex
		   (public member function)
	  unlock   unlocks the associated mutex
		   (public member function)

http://cppreference.com		  2022.07.31	     std::shared_lock::lock(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::shared_lock::lock&sektion=3&manpath=FreeBSD+Ports+15.0>

home | help