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

FreeBSD Manual Pages

  
 
  

home | help 
std::timed_...ry_lock_for(3)  C++ Standard Libary std::timed_...ry_lock_for(3)

NAME
       std::timed_mutex::try_lock_for -	std::timed_mutex::try_lock_for

Synopsis
	  template< class Rep, class Period >
	  bool	 try_lock_for(	 const	 std::chrono::duration<Rep,   Period>&
       (since C++11)
	  timeout_duration );

	  Tries	to lock	the mutex. Blocks until	the specified  duration	 time-
       out_duration has
	  elapsed  (timeout)  or  the  lock  is	 acquired  (owns  the  mutex),
       whichever comes first.
	  On successful	 lock  acquisition  returns  true,  otherwise  returns
       false.

	  If  timeout_duration	is  less or equal timeout_duration.zero(), the
       function	behaves
	  like try_lock().

	  This function	may block for  longer  than  timeout_duration  due  to
       scheduling or
	  resource contention delays.

	  The  standard	recommends that	a std::steady_clock is used to measure
       the duration. If
	  an implementation uses a std::system_clock instead,  the  wait  time
       may also	be
	  sensitive to clock adjustments.

	  As  with try_lock(), this function is	allowed	to fail	spuriously and
       return false
	  even if the mutex was	not locked by any other	thread at  some	 point
       during
	  timeout_duration.

	  Prior	unlock() operation on the same mutex synchronizes-with (as de-
       fined in
	  std::memory_order) this operation if it returns true.

	  If  try_lock_for  is called by a thread that already owns the	mutex,
       the behavior is
	  undefined.

Parameters
	  timeout_duration - minimum duration to block for

Return value
	  true if the lock was acquired	successfully, otherwise	false.

Exceptions
	  Any exception	thrown by timeout_duration (durations provided by  the
       standard	library
	  never	throw).

Example
       // Run this code

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

	using namespace	std::chrono_literals;

	std::mutex cout_mutex; // control access to std::cout
	std::timed_mutex mutex;

	void job(int id)
	{
	    std::ostringstream stream;

	    for	(int i = 0; i <	3; ++i)
	    {
		if (mutex.try_lock_for(100ms))
		{
		    stream << "success ";
		    std::this_thread::sleep_for(100ms);
		    mutex.unlock();
		}
		else
		    stream << "failed ";

		std::this_thread::sleep_for(100ms);
	    }

	    std::lock_guard<std::mutex>	lock{cout_mutex};
	    std::cout << '[' <<	id << "] " << stream.str() << '\n';
	}

	int main()
	{
	    std::vector<std::thread> threads;
	    for	(int i{0}; i < 4; ++i)
		threads.emplace_back(job, i);

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

Possible output:
	[0] failed failed failed
	[3] failed failed success
	[2] failed success failed
	[1] success failed success

	 Defect	reports

	  The following	behavior-changing defect reports were applied retroac-
       tively to
	  previously published C++ standards.

	     DR	    Applied  to	  Behavior as published		   Correct be-
       havior
	  LWG 2093 C++11      try_lock_for threw  nothing  throws  timeout-re-
       lated exceptions

See also
	  lock		 locks the mutex, blocks if the	mutex is not available
			 (public member	function)
	  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_until  unavailable  until  specified	 time  point  has been
       reached
			 (public member	function)
	  unlock	 unlocks the mutex
			 (public member	function)

http://cppreference.com		  2024.06.10	  std::timed_...ry_lock_for(3)

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

home | help