home | help 
std::shared_timed_mutex(3)     C++ Standard Libary    std::shared_timed_mutex(3)

NAME
     std::shared_timed_mutex - std::shared_timed_mutex

Synopsis
	Defined in header <shared_mutex>
	class shared_timed_mutex;	  (since C++14)

	The  shared_timed_mutex class is a synchronization primitive that can be
     used to
	protect shared data  from  being  simultaneously  accessed  by	multiple
     threads. In
	contrast to other mutex types which facilitate exclusive access, a
	shared_timed_mutex has two levels of access:

	  * exclusive - only one thread can own the mutex.
	  * shared - several threads can share ownership of the same mutex.

	Shared	mutexes are usually used in situations when multiple readers can
     access the
	same resource at the same time without causing data races, but only  one
     writer can
	do so.

	In  a  manner  similar	to  timed_mutex, shared_timed_mutex provides the
     ability to
	attempt to claim ownership of a shared_timed_mutex with  a  timeout  via
     the
	try_lock_for(), 	try_lock_until(),	  try_lock_shared_for(),
     try_lock_shared_until()
	member functions.

	The shared_timed_mutex class satisfies all requirements of  SharedTimed-
     Mutex and
	StandardLayoutType.

Member functions
	constructor	      constructs the mutex
			      (public member function)
	destructor	      destroys the mutex
			      (public member function)
	operator=	      not copy-assignable
	[deleted]	      (public member function)
	      Exclusive locking
	lock		      locks the mutex, blocks if the mutex is not avail-
     able
			      (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)
			      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)

Shared locking
			      locks  the  mutex  for shared ownership, blocks if
     the mutex is
	lock_shared	      not available
			      (public member function)
			      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_for   mutex has been
			      unavailable for the specified timeout duration
			      (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)
	unlock_shared	      unlocks the mutex (shared ownership)
			      (public member function)

Notes
	     Feature-test macro       Value    Std	     Feature
	__cpp_lib_shared_timed_mutex 201402L (C++14) std::shared_timed_mutex

Example
	 This section is incomplete
	 Reason: build a motivating example

	A copy assignment operator for a class that  holds  resources  that  can
     handle multiple
	readers, but only one writer.

     // Run this code

      #include <mutex>
      #include <shared_mutex>

      class R
      {
	  mutable std::shared_timed_mutex mut;
	  /* data */
      public:
	  R& operator=(const R& other)
	  {
	      // requires exclusive ownership to write to *this
	      std::unique_lock<std::shared_timed_mutex>     lhs(mut,	std::de-
     fer_lock);
	      // requires shared ownership to read from other
	      std::shared_lock<std::shared_timed_mutex> rhs(other.mut,	std::de-
     fer_lock);
	      std::lock(lhs, rhs);
	      /* assign data */
	      return *this;
	  }
      };

      int main()
      {
	  R r;
      }

Category:
	  * Todo with reason

http://cppreference.com 	   2024.06.10	      std::shared_timed_mutex(3)
home | help