#include <Semaphore.h>
Public Member Functions | |
ACE_Semaphore (unsigned int count=1, int type=USYNC_THREAD, const ACE_TCHAR *name=0, void *=0, int max=0x7fffffff) | |
Initialize the semaphore, with initial value of "count". | |
~ACE_Semaphore (void) | |
Implicitly destroy the semaphore. | |
int | remove (void) |
int | acquire (void) |
int | acquire (ACE_Time_Value &tv) |
int | acquire (ACE_Time_Value *tv) |
int | tryacquire (void) |
int | release (void) |
int | release (unsigned int release_count) |
int | acquire_read (void) |
int | acquire_write (void) |
int | tryacquire_read (void) |
int | tryacquire_write (void) |
int | tryacquire_write_upgrade (void) |
void | dump (void) const |
Dump the state of an object. | |
const ACE_sema_t & | lock (void) const |
Return the underlying lock. | |
Public Attributes | |
ACE_ALLOC_HOOK_DECLARE | |
Declare the dynamic allocation hooks. | |
Protected Attributes | |
ACE_sema_t | semaphore_ |
bool | removed_ |
Private Member Functions | |
void | operator= (const ACE_Semaphore &) |
ACE_Semaphore (const ACE_Semaphore &) |
ACE_Semaphore::ACE_Semaphore | ( | unsigned int | count = 1 , |
|
int | type = USYNC_THREAD , |
|||
const ACE_TCHAR * | name = 0 , |
|||
void * | arg = 0 , |
|||
int | max = 0x7fffffff | |||
) |
Initialize the semaphore, with initial value of "count".
ACE_Semaphore::~ACE_Semaphore | ( | void | ) |
Implicitly destroy the semaphore.
ACE_Semaphore::ACE_Semaphore | ( | const ACE_Semaphore & | ) | [private] |
int ACE_Semaphore::acquire | ( | ACE_Time_Value * | tv | ) |
If tv == 0 then call <acquire()> directly. Otherwise, Block the thread until the semaphore count becomes greater than 0 (at which point it is decremented) or until tv times out (in which case -1 is returned and errno
== ETIME
). Note that <*tv> is assumed to be in "absolute" rather than "relative" time. The value of <*tv> is updated upon return to show the actual (absolute) acquisition time.
int ACE_Semaphore::acquire | ( | ACE_Time_Value & | tv | ) |
Block the thread until the semaphore count becomes greater than 0 (at which point it is decremented) or until tv times out (in which case -1 is returned and errno
== ETIME
). Note that tv is assumed to be in "absolute" rather than "relative" time. The value of tv is updated upon return to show the actual (absolute) acquisition time.
int ACE_Semaphore::acquire | ( | void | ) |
Block the thread until the semaphore count becomes greater than 0, then decrement it.
int ACE_Semaphore::acquire_read | ( | void | ) |
Acquire semaphore ownership. This calls <acquire> and is only here to make the ACE_Semaphore interface consistent with the other synchronization APIs.
int ACE_Semaphore::acquire_write | ( | void | ) |
Acquire semaphore ownership. This calls <acquire> and is only here to make the ACE_Semaphore interface consistent with the other synchronization APIs.
void ACE_Semaphore::dump | ( | void | ) | const |
Dump the state of an object.
const ACE_sema_t & ACE_Semaphore::lock | ( | void | ) | const |
Return the underlying lock.
void ACE_Semaphore::operator= | ( | const ACE_Semaphore & | ) | [private] |
int ACE_Semaphore::release | ( | unsigned int | release_count | ) |
Increment the semaphore by release_count, potentially unblocking waiting threads.
int ACE_Semaphore::release | ( | void | ) |
Increment the semaphore by 1, potentially unblocking a waiting thread.
int ACE_Semaphore::remove | ( | void | ) |
Explicitly destroy the semaphore. Note that only one thread should call this method since it doesn't protect against race conditions.
int ACE_Semaphore::tryacquire | ( | void | ) |
Conditionally decrement the semaphore if count is greater than 0 (i.e., won't block). Returns -1 on failure. If we "failed" because someone else already had the lock, errno
is set to EBUSY
.
int ACE_Semaphore::tryacquire_read | ( | void | ) |
Conditionally acquire semaphore (i.e., won't block). This calls <tryacquire> and is only here to make the ACE_Semaphore interface consistent with the other synchronization APIs. Returns -1 on failure. If we "failed" because someone else already had the lock, errno
is set to EBUSY
.
int ACE_Semaphore::tryacquire_write | ( | void | ) |
Conditionally acquire semaphore (i.e., won't block). This calls <tryacquire> and is only here to make the ACE_Semaphore interface consistent with the other synchronization APIs. Returns -1 on failure. If we "failed" because someone else already had the lock, errno
is set to EBUSY
.
int ACE_Semaphore::tryacquire_write_upgrade | ( | void | ) |
This is only here to make the ACE_Semaphore interface consistent with the other synchronization APIs. Assumes the caller has already acquired the semaphore using one of the above calls, and returns 0 (success) always.
Declare the dynamic allocation hooks.
bool ACE_Semaphore::removed_ [protected] |
Keeps track of whether remove() has been called yet to avoid multiple remove() calls, e.g., explicitly and implicitly in the destructor. This flag isn't protected by a lock, so make sure that you don't have multiple threads simultaneously calling remove () on the same object, which is a bad idea anyway...
ACE_sema_t ACE_Semaphore::semaphore_ [protected] |