home | help 
std::shared...try_lock_for(3)  C++ Standard Libary std::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 the specified duration timeout_du-
     ration 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  func-
     tion behaves
	like try_lock().

	This function may block for longer than timeout_duration due to schedul-
     ing 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 re-
     turn false
	even if the mutex was not locked by any other thread at some point  dur-
     ing
	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_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  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

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::shared...try_lock_for(3)
home | help