bslmt::Latch Class Reference

#include <bslmt_latch.h>

Detailed Description

This class defines a thread synchronization mechanism that allows one or more threads to wait until a certain number of operations have been performed by other threads.

See bslmt_latch

Public Types
enum	{ e_TIMED_OUT = Condition::e_TIMED_OUT }

Public Member Functions
	Latch (int count, bsls::SystemClockType::Enum clockType=bsls::SystemClockType::e_REALTIME)
	~Latch ()
void	arrive ()
void	arriveAndWait ()
void	countDown (int numEvents)
int	timedWait (const bsls::TimeInterval &absTime)
void	wait ()
bsls::SystemClockType::Enum	clockType () const
int	currentCount () const
bool	tryWait () const

Member Enumeration Documentation

anonymous enum

anonymous enum

The value timedWait returns when a timeout occurs.

Enumerator
e_TIMED_OUT

Constructor & Destructor Documentation

Latch()

bslmt::Latch::Latch ( int  count, bsls::SystemClockType::Enum  clockType = bsls::SystemClockType::e_REALTIME  )

inlineexplicit

Create a latch that will synchronize on the specified count number of events, and when count events have been recorded will release any waiting threads. Optionally specify a clockType indicating the type of the system clock against which the bsls::TimeInterval absTime timeouts passed to the timedWait method are to be interpreted. If clockType is not specified then the realtime system clock is used.

Precondition

The behavior is undefined unless 0 <= count.

~Latch()

bslmt::Latch::~Latch

(

)

Destroy this latch.

Precondition

The behavior is undefined if any threads are waiting on this latch.

Member Function Documentation

arrive()

void bslmt::Latch::arrive

(

)

Decrement the number of events that this latch is waiting for by 1, and if the resulting number of events is 0 release any waiting threads.

Precondition

The behavior is undefined unless the sum of all events that have arrived at this latch does not exceed the count with which it was initialized.

Note

Note that the initial count of events is supplied at construction.

arriveAndWait()

void bslmt::Latch::arriveAndWait

(

)

Decrement the number of events that this latch is waiting for by 1, and if the resulting number of events is 0 release any waiting threads; otherwise, block until the required number of events has been reached.

Precondition

The behavior is undefined unless the sum of all events that have arrived at this latch does not exceed the count with which it was initialized.

Note

Note that the initial count of events is supplied at construction. Also note that this method is equivalent to the following sequence:

arrive();
wait();

clockType()

bsls::SystemClockType::Enum bslmt::Latch::clockType ( ) const

inline

Return the clock type used for timeouts.

countDown()

void bslmt::Latch::countDown

(

int

numEvents

)

Decrement the number of events that this latch is waiting for by the specified numEvents, and if the resulting number of events is 0 release any waiting threads.

Precondition

The behavior is undefined unless numEvents > 0 and the sum of all events that have arrived at this latch does not exceed the count with which it was initialized.

Note

Note that the initial count of events is supplied at construction.

currentCount()

int bslmt::Latch::currentCount

(

)

const

Return the current number of events for which this latch is waiting.

Note

Note that this method is provided primarily for debugging purposes (i.e., its intended use is not as a synchronization mechanism), and can be used only as an upper bound for the current count without other external state information.

timedWait()

int bslmt::Latch::timedWait

(

const bsls::TimeInterval &

absTime

)

Block until the number of events that this latch is waiting for reaches 0, or until the specified absTime timeout expires. Return 0 on success, e_TIMED_OUT on timeout, and a non-zero value different from e_TIMED_OUT if an error occurs. Errors are unrecoverable. After an error, the latch may be destroyed, but any other use has undefined behavior. absTime is an absolute time represented as an interval from some epoch as determined by the clock specified at construction (see {Supported Clock-Types} in the component-level documentation).

Note

Note that a return value of 0 does not guarantee this object is safe to destroy.

tryWait()

bool bslmt::Latch::tryWait

(

)

const

Return true if this latch has already been released (i.e., the number of events the latch is waiting on is 0), and false otherwise. This method does not block.

Note

Note that a return value of true indicates a permanent state change (the latch has released and will never be un-released), but a return value of false is ephemeral and cannot typically be acted upon without additional external state information. Also note that a return value of true does not guarantee this object is safe to destroy.

wait()

void bslmt::Latch::wait

(

)

Block until the number of events that this latch is waiting for reaches 0.

Note

Note that completion of this method does not guarantee this object is safe to destroy.

---

The documentation for this class was generated from the following file:

• bslmt_latch.h