home | help 
std::unique...:unique_lock(3)  C++ Standard Libary std::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.  Addition-
     ally:
	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 behavior
     is undefined
	if not so.
	7) Tries to lock the associated mutex  by  calling  m.try_lock_for(time-
     out_duration).
	Blocks	until  specified timeout_duration has elapsed or the lock is ac-
     quired,
	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_until(time-
     out_time).
	Blocks until specified timeout_time has been reached or the lock is  ac-
     quired,
	whichever  comes first. May block for longer than until timeout_time has
     been
	reached. The behavior is undefined if Mutex does not satisfy  TimedLock-
     able.

Parameters
	other		 - another unique_lock to initialize the state with
	m		  -  mutex to associate with the lock and optionally ac-
     quire ownership
			   of
	t		 - tag parameter used to select constructors  with  dif-
     ferent 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 alter-
     natives
	      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)
home | help