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

FreeBSD Manual Pages

  
 
  

home | help 
std::shared...try_lock_for(3) C++ Standard Libarystd::shared...try_lock_for(3)

NAME
       std::shared_timed_mutex::try_lock_for	  -	 std::shared_timed_mu-
       tex::try_lock_for

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

	  Tries	to lock	the mutex. Blocks until	specified timeout_duration has
       elapsed or the
	  lock is acquired, whichever comes first. On successful lock acquisi-
       tion 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 steady_clock	is used	to measure the
       duration. If an
	  implementation uses a	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 in
       any mode
	  (shared or exclusive), 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 clock, time_point,	or duration during the
       execution (clocks,
	  time points, and durations provided by the  standard	library	 never
       throw)

Example
       // Run this code

	#include <iostream>
	#include <mutex>
	#include <chrono>
	#include <thread>
	#include <vector>
	#include <sstream>
	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& i: threads) {
		i.join();
	    }
	}

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

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		  2022.07.31	 std::shared...try_lock_for(3)

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

home | help