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

FreeBSD Manual Pages

  
 
  

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

NAME
       std::shared_timed_mutex::try_lock_until	   -	 std::shared_timed_mu-
       tex::try_lock_until

Synopsis
	  template< class Clock, class Duration	>
	  bool try_lock_until( const  std::chrono::time_point<Clock,Duration>&
       (since C++14)
	  timeout_time );

	  Tries	 to  lock  the	mutex. Blocks until specified timeout_time has
       been reached or the
	  lock is acquired, whichever comes first. On successful lock acquisi-
       tion returns
	  true,	otherwise returns false.

	  If timeout_time has  already	passed,	 this  function	 behaves  like
       try_lock().

	  Clock	must meet the Clock requirements.
	  The  programs	 is  ill-formed	 if  std::chrono::is_clock_v<Clock> is
       false
	  (since C++20).

	  The standard recommends that the clock tied to timeout_time be used,
       in which	case
	  adjustments of the clock may be taken	into account. Thus, the	 dura-
       tion of the block
	  might,   but	might  not,  be	 less  or  more	 than  timeout_time  -
       Clock::now() at the time
	  of the call, depending  on  the  direction  of  the  adjustment  and
       whether it is honored
	  by  the  implementation. The function	also may block for longer than
       until after
	  timeout_time has been	reached	due to	scheduling  or	resource  con-
       tention delays.

	  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
       before
	  timeout_time.

	  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_until is	called by a thread that	already	owns the mutex
       in any mode
	  (shared or exclusive), the behavior is undefined.

Parameters
	  timeout_time - maximum time point to block until

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
	  This example shows a 10 seconds block

       // Run this code

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

	std::shared_timed_mutex	test_mutex;

	void f()
	{
	    auto now=std::chrono::steady_clock::now();
	    test_mutex.try_lock_until(now + std::chrono::seconds(10));
	    std::cout << "hello	world\n";
	}

	int main()
	{
	    std::lock_guard<std::shared_timed_mutex> l(test_mutex);
	    std::thread	t(f);
	    t.join();
	}

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_for unavailable for the specified timeout duration
		       (public member function)
	  unlock       unlocks the mutex
		       (public member function)

http://cppreference.com		  2022.07.31	 std::shared...y_lock_until(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_until&sektion=3&manpath=FreeBSD+Ports+15.0>

home | help