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

FreeBSD Manual Pages

  
 
  

home | help 
std::recurs...mutex::lock(3)  C++ Standard Libary std::recurs...mutex::lock(3)

NAME
       std::recursive_timed_mutex::lock	- std::recursive_timed_mutex::lock

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

	  Locks	 the  mutex. If	another	thread has already locked the mutex, a
       call to lock will
	  block	execution until	the lock is acquired.

	  A thread may call lock on a recursive	 mutex	repeatedly.  Ownership
       will only be
	  released  after  the	thread makes a matching	number of calls	to un-
       lock.

	  The maximum number of	levels of ownership is unspecified. An	excep-
       tion of type
	  std::system_error will be thrown if this number is exceeded.

	  Prior	unlock() operations on the same	mutex synchronize-with (as de-
       fined in
	  std::memory_order) this operation.

Parameters
	  (none)

Return value
	  (none)

Exceptions
	  Throws  std::system_error  when  errors occur, including errors from
       the underlying
	  operating system that	would prevent lock from	meeting	its specifica-
       tions. The mutex
	  is not locked	in the case of any exception being thrown.

Notes
	  lock()   is	usually	  not	called	 directly:   std::unique_lock,
       std::scoped_lock, and
	  std::lock_guard are used to manage exclusive locking.

Example
	  This example shows how lock and unlock can be	used to	protect	shared
       data.

       // Run this code

	#include <iostream>
	#include <chrono>
	#include <thread>
	#include <mutex>

	int g_num = 0;	// protected by	g_num_mutex
	std::mutex g_num_mutex;

	void slow_increment(int	id)
	{
	    for	(int i = 0; i <	3; ++i)	{
		g_num_mutex.lock();
		++g_num;
		// note, that the mutex	also syncronizes the output
		std::cout << "id: " << id << ",	g_num: " << g_num << '\n';
		g_num_mutex.unlock();

		std::this_thread::sleep_for(std::chrono::milliseconds(234));
	    }
	}

	int main()
	{
	    std::thread	t1{slow_increment, 0};
	    std::thread	t2{slow_increment, 1};
	    t1.join();
	    t2.join();
	}

Possible output:
	id: 0, g_num: 1
	id: 1, g_num: 2
	id: 1, g_num: 3
	id: 0, g_num: 4
	id: 0, g_num: 5
	id: 1, g_num: 6

See also
	  try_lock	  tries	to lock	the mutex, returns if the mutex	is not
       available
			 (public member	function)
			 tries to lock the mutex, returns  if  the  mutex  has
       been
	  try_lock_for	 unavailable for the specified timeout duration
			 (public member	function)
			 tries	to  lock  the  mutex, returns if the mutex has
       been
	  try_lock_until unavailable  until  specified	time  point  has  been
       reached
			 (public member	function)
	  unlock	 unlocks the mutex
			 (public member	function)

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

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

home | help