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 <mutex>
	#include <thread>
	#include <iostream>
	#include <vector>
	#include <chrono>

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

	    auto worker_task = [&](int id, int wait_seconds, int  acquire_sec-
       onds) {
		// wait	for a few seconds before acquiring lock.
		std::this_thread::sleep_for(std::chrono::seconds(wait_sec-
       onds));

		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(std::chrono::seconds(acquire_sec-
       onds));

		std::cout << id	<< ", releasing	lock.\n";
		lock.unlock();
	    };

	    threads.emplace_back(worker_task, 0, 0, 2);
	    threads.emplace_back(worker_task, 1, 1, 0);
	    threads.emplace_back(worker_task, 2, 3, 0);

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

Output:
	0, lock	acquired.
	1, failed acquiring lock.
	0, releasing lock.
	2, lock	acquired.
	2, releasing lock.

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		  2022.07.31	 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.0>

home | help