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

FreeBSD Manual Pages

  
 
  

home | help 
std::unique...:unique_lock(3) C++ Standard Libarystd::unique...:unique_lock(3)

NAME
       std::unique_lock::unique_lock - std::unique_lock::unique_lock

Synopsis
	  unique_lock()						     noexcept;
       (1) (since C++11)
	  unique_lock(	     unique_lock&&	 other	     )	     noexcept;
       (2) (since C++11)
	  explicit	   unique_lock(		mutex_type&	   m	    );
       (3) (since C++11)
	  unique_lock(	mutex_type&  m,	 std::defer_lock_t   t	 )   noexcept;
       (4) (since C++11)
	  unique_lock(	   mutex_type&	   m,	 std::try_to_lock_t    t    );
       (5) (since C++11)
	  unique_lock(	  mutex_type&	 m,	std::adopt_lock_t     t	    );
       (6) (since C++11)
	  template< class Rep, class Period >

	  unique_lock(			    mutex_type&			    m,
       (7) (since C++11)

		       const std::chrono::duration<Rep,	Period>&
	  timeout_duration );
	  template< class Clock, class Duration	>

	  unique_lock(			   mutex_type&			    m,
       (8) (since C++11)

		       const std::chrono::time_point<Clock, Duration>&
	  timeout_time );

	  Constructs a unique_lock, optionally locking the supplied mutex.

	  1) Constructs	a unique_lock with no associated mutex.
	  2)  Move  constructor. Initializes the unique_lock with the contents
       of other. Leaves
	  other	with no	associated mutex.
	  3-8) Constructs a unique_lock	with m as the associated mutex.	 Addi-
       tionally:
	  3) Locks the associated mutex	by calling m.lock().
	  4) Does not lock the associated mutex.
	  5)  Tries  to	 lock the associated mutex without blocking by calling
       m.try_lock(). The
	  behavior is undefined	if Mutex does not satisfy Lockable.
	  6) Assumes the calling thread	already	holds a	non-shared lock	(i.e.,
       a lock acquired
	  by lock, try_lock, try_lock_for, or try_lock_until) on m. The	behav-
       ior is undefined
	  if not so.
	  7)   Tries   to   lock   the	  associated	mutex	 by    calling
       m.try_lock_for(timeout_duration).
	  Blocks  until	 specified timeout_duration has	elapsed	or the lock is
       acquired,
	  whichever comes first. May block for longer  than  timeout_duration.
       The behavior is
	  undefined if Mutex does not satisfy TimedLockable.
	  8)  Tries  to	 lock  the  associated mutex by	calling	m.try_lock_un-
       til(timeout_time).
	  Blocks until specified timeout_time has been reached or the lock  is
       acquired,
	  whichever  comes first. May block for	longer than until timeout_time
       has been
	  reached. The behavior	is undefined if	Mutex does not satisfy	Timed-
       Lockable.

Parameters
	  other		   - another unique_lock to initialize the state with
	  m		    -  mutex to	associate with the lock	and optionally
       acquire ownership
			     of
	  t		   - tag parameter used	to  select  constructors  with
       different locking
			     strategies
	  timeout_duration - maximum duration to block for
	  timeout_time	   - maximum time point	to block until

Example
       // Run this code

	#include <iostream>
	#include <mutex>
	#include <thread>
	#include <utility>
	#include <vector>

	std::mutex m_a,	m_b, m_c;
	int a, b, c = 1;

	void update()
	{
	    {	// Note: std::lock_guard or atomic<int>	can be used instead
		std::unique_lock<std::mutex> lk(m_a);
		++a;
	    }

	    {	 //  Note:  see	std::lock and std::scoped_lock for details and
       alternatives
		std::unique_lock<std::mutex> lk_b(m_b, std::defer_lock);
		std::unique_lock<std::mutex> lk_c(m_c, std::defer_lock);
		std::lock(lk_b,	lk_c);
		b = std::exchange(c, b + c);
	    }
	}

	int main()
	{
	    std::vector<std::thread> threads;
	    for	(unsigned i = 0; i < 12; ++i)
		threads.emplace_back(update);

	    for	(auto& i : threads)
		i.join();

	    std::cout << a << "'th and " << a +	1 << "'th Fibonacci numbers: "
		      << b << "	and " << c << '\n';
	}

Output:
	12'th and 13'th	Fibonacci numbers: 144 and 233

http://cppreference.com		  2024.06.10	 std::unique...:unique_lock(3)

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

home | help