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

FreeBSD Manual Pages

  
 
  

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

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

Synopsis
	  bool try_lock();  (since C++11)

	  Tries	 to lock (i.e.,	takes ownership	of) the	associated mutex with-
       out blocking.
	  Effectively calls mutex()->try_lock().

	  std::system_error is thrown if there is no associated	 mutex	or  if
       the mutex is
	  already locked by this std::unique_lock.

Parameters
	  (none)

Return value
	  true	if  the	ownership of the mutex has been	acquired successfully,
       false otherwise.

Exceptions
	    * Any exceptions thrown by mutex()->try_lock() (Mutex types	do not
       throw in
	      try_lock,	but a custom Lockable might).
	    * If there is no associated	mutex, std::system_error with an error
       code of
	      std::errc::operation_not_permitted.
	    * If  the  mutex  is  already  locked  by  this  std::unique_lock,
       std::system_error with
	      an error code of std::errc::resource_deadlock_would_occur.

Example
	  The  following  examples  try	to acquire a mutex that	was locked and
       unlocked.

       // Run this code

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

	using namespace	std::chrono_literals;

	int main()
	{
	    std::mutex counter_mutex;
	    std::vector<std::thread> threads;
	    using Id = int;

	    auto  worker_task  =   [&](Id   id,	  std::chrono::seconds	 wait,
       std::chrono::seconds acquire)
	    {
		// wait	for a few seconds before acquiring lock.
		std::this_thread::sleep_for(wait);

		std::unique_lock<std::mutex>	lock(counter_mutex,   std::de-
       fer_lock);
		if (lock.try_lock())
		    std::cout << '#' <<	id << ", lock acquired.\n";
		else
		{
		    std::cout << '#' <<	id << ", failed	acquiring lock.\n";
		    return;
		}

		// keep	the lock for a while.
		std::this_thread::sleep_for(acquire);

		std::cout << '#' << id <<  ",  releasing  lock	(via  destruc-
       tor).\n";
	    };

	    threads.emplace_back(worker_task, Id{0}, 0s, 2s);
	    threads.emplace_back(worker_task, Id{1}, 1s, 0s);
	    threads.emplace_back(worker_task, Id{2}, 3s, 0s);

	    for	(auto& thread :	threads)
		thread.join();
	}

Output:
	#0, lock acquired.
	#1, failed acquiring lock.
	#0, releasing lock (via	destructor).
	#2, lock acquired.
	#2, releasing lock (via	destructor).

See also
	  lock		 locks (i.e., takes ownership of) the associated mutex
			 (public member	function)
			 attempts to lock (i.e., takes ownership of) the asso-
       ciated
	  try_lock_for	  TimedLockable	 mutex,	 returns if the	mutex has been
       unavailable for
			 the specified time duration
			 (public member	function)
			 tries to lock (i.e., takes ownership of) the  associ-
       ated TimedLockable
	  try_lock_until  mutex, returns if the	mutex has been unavailable un-
       til specified time
			 point has been	reached
			 (public member	function)
	  unlock	 unlocks (i.e.,	releases ownership of) the  associated
       mutex
			 (public member	function)

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

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

home | help