Class that allows up to max_simultaneous_locks concurrent accesses to the critical section. It ignores task cancellation, unlike CancellableSemaphore .
More...
#include <userver/engine/semaphore.hpp >
Semaphore (Counter capacity) Semaphore (Semaphore &&)=delete Semaphore (const Semaphore &)=delete Semaphore & operator= (Semaphore &&)=delete Semaphore & operator= (const Semaphore &)=delete void SetCapacity (Counter capacity) GetCapacity () const noexcept Gets the total number of available locks. RemainingApprox () const Returns an approximate number of available locks, use only for statistics. UsedApprox () const Returns an approximate number of used locks, use only for statistics. void lock_shared () void unlock_shared () try_lock_shared () template<typename Rep , typename Period > bool try_lock_shared_for (std::chrono::duration< Rep, Period >) template<typename Clock , typename Duration > bool try_lock_shared_until (std::chrono::time_point< Clock, Duration >) try_lock_shared_until (Deadline deadline) lock_shared_count (Counter count) unlock_shared_count (Counter count) try_lock_shared_count (Counter count) try_lock_shared_until_count (Deadline deadline, Counter count)
Class that allows up to max_simultaneous_locks concurrent accesses to the critical section. It ignores task cancellation, unlike CancellableSemaphore .
constexpr auto kMaxSimultaneousLocks = 3;
{
std::shared_lock lock(sema);
}
See also Synchronization Primitives Definition at line 136 of file semaphore.hpp .
◆
using engine::Semaphore::Counter = std::size_t
◆
engine::Semaphore::Semaphore
(
Counter
capacity )
explicit
Creates a semaphore with predefined number of available locks
Parameters
capacity initial number of available locks
◆
void engine::Semaphore::lock_shared
(
)
Decrements internal semaphore lock counter. Blocks if current counter is zero until the subsequent call to unlock_shared() by another coroutine.
Note the user must eventually call unlock_shared() to increment the lock counter.
the method waits for the semaphore even if the current task is cancelled. Exceptions
◆
void engine::Semaphore::SetCapacity
(
Counter
capacity )
Sets the total number of available locks. If the lock count decreases, the current acquired lock count may temporarily go above the limit.
◆
template<typename Rep , typename Period >
bool engine::Semaphore::try_lock_shared_for
(
std::chrono::duration< Rep, Period >
duration )
◆
template<typename Clock , typename Duration >
bool engine::Semaphore::try_lock_shared_until
(
std::chrono::time_point< Clock, Duration >
until )
◆
void engine::Semaphore::unlock_shared
(
)
Increments internal semaphore lock counter. If there is a user waiting in lock_shared() on the same semaphore, it will be waken up.
Note the order of coroutines to unblock is unspecified. Any code assuming any specific order (e.g. FIFO) is incorrect and must be fixed.
it is allowed to call lock_shared() in one coroutine and subsequently call unlock_shared() in another coroutine. In particular, it is allowed to pass std::shared_lock<engine::Semaphore> across coroutines.
The documentation for this class was generated from the following file:
