home | help
std::shared..._shared_for(3)   C++ Standard Libary  std::shared..._shared_for(3)

NAME
     std::shared_timed_mutex::try_lock_shared_for     -    std::shared_timed_mu-
     tex::try_lock_shared_for

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

	Tries  to  lock  the  mutex in shared mode. Blocks until specified time-
     out_duration has
	elapsed or the shared lock is acquired, whichever comes first.	On  suc-
     cessful lock
	acquisition returns true, otherwise returns false.

	If  timeout_duration is less or equal timeout_duration.zero(), the func-
     tion behaves
	like try_lock_shared().

	This function may block for longer than timeout_duration due to schedul-
     ing or
	resource contention delays.

	The standard recommends that a steady clock is used to measure the dura-
     tion. If an
	implementation uses a system clock instead, the wait time  may	also  be
     sensitive to
	clock adjustments.

	As  with  try_lock_shared(), 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 defined
     in
	std::memory_order) this operation if it returns true.

	If try_lock_shared_for is called by a thread that already owns the mutex
     in any mode
	(shared or exclusive), the behavior is undefined.

Parameters
	timeout_duration - maximum 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 execu-
     tion (clocks,
	time points, and  durations  provided  by  the	standard  library  never
     throw).

Example
	 This section is incomplete
	 Reason: no example

See also
			      tries  to lock the mutex for shared ownership, re-
     turns if the
	try_lock_shared       mutex is not available
			      (public member function)
			      tries to lock the mutex for shared ownership,  re-
     turns if the
	try_lock_shared_until mutex has been
			      unavailable  until  specified  time point has been
     reached
			      (public member function)
			      tries to lock the mutex, returns if the mutex  has
     been
	try_lock_for	      unavailable for the specified timeout duration
			      (public member function)

Category:
	  * Todo no example

http://cppreference.com 	   2024.06.10	    std::shared..._shared_for(3)

home | help