Main Page   Namespace List   Class Hierarchy   Compound List   Namespace Members   Compound Members  

Semaphore Class Reference

#include <Semaphore.h>

Inheritance diagram for Semaphore:

Lockable NonCopyable List of all members.

Public Methods

 Semaphore (int count=1, unsigned int maxCount=1)
virtual ~Semaphore () throw ()
 Destroy the Semaphore.

void wait ()
bool tryWait (unsigned long)
void post ()
virtual int count () throw ()
virtual bool tryAcquire (unsigned long timeout)
virtual void acquire ()
virtual void release ()

Detailed Description

Author:
Eric Crahen <crahen@cse.buffalo.edu>
Date:
<2002-06-02T08:11:14-0400>
Version:
2.2.1
A Semaphore is an ownerless Lockable object. Its probably best described as a set of 'permits'. A Semaphore is initlized with an intial count and a maximum count, these would correspond to the number of 'permits' currently available and the number of' permits' in total.

acquire()ing the Semaphore means taking a permit, but if there are none (the count is 0) the Semaphore will block the calling thread.

release()ing the Semaphore means returning a permit, unblocking a thread waiting for one.

A Semaphore with an initial value of 1 and maximum value of 1 will act as a Mutex.

Scheduling

Threads blocked on a Semaphore are resumed in FIFO order.

Error Checking

An attempt to increase a Semaphore beyond its maximum value will result in an InvalidOp_Exception.


Constructor & Destructor Documentation

Semaphore int    count = 1,
unsigned int    maxCount = 1
 

Create a new Semaphore.

Parameters:
count  - initial count
maxCount  - upper bound
Exceptions:
Synchronization_Exception  thrown if the Semaphore could not be created


Member Function Documentation

virtual void acquire   [virtual]
 

Decrement the count, blocking that calling thread if the count becomes 0 or less than 0. The calling thread will remain blocked until the count is raised above 0 or if an exception is thrown.

Exceptions:
Interrupted_Exception  thrown when the calling thread is interupt()ed. A thread may be interrupted at any time, prematurely ending any wait.
Synchronization_Exception  thrown if there is some other error.
See also:
Lockable::acquire()

Implements Lockable.

virtual int count   throw () [virtual]
 

Get the current count of the semaphore. This value may change immediately after this function returns to the calling thread.

Returns :
int - count

void post  
 

Increment the count.

See also:
release() - provided to reflect the traditional Semaphore semantics

virtual void release   [virtual]
 

Increment the count, unblocking one thread if count is posative.

Exceptions:
InvalidOp_Exception  thrown if this operation would increase the count beyond the maximum
Synchronization_Exception  thrown if there is some other error.
See also:
Lockable::release()

Implements Lockable.

virtual bool tryAcquire unsigned long    timeout [virtual]
 

Decrement the count, blocking that calling thread if the count becomes 0 or less than 0. The calling thread will remain blocked until the count is raised above 0, an exception is thrown or the given amount of time expires.

Parameters:
timeout  - maximum amount of time (milliseconds) this method could block
Returns :
bool true if the Semaphore was acquire()ed before the timeout expired, otherwise false
Exceptions:
Interrupted_Exception  thrown when the calling thread is interupt()ed. A thread may be interrupted at any time, prematurely ending any wait.
Synchronization_Exception  thrown if there is some other error.
See also:
Lockable::tryAcquire(unsigned long)

Implements Lockable.

bool tryWait unsigned    long
 

Decrement the count.

See also:
tryAcquire() - provided to reflect the traditional Semaphore semantics

void wait  
 

Decrement the count.

See also:
acquire() - provided to reflect the traditional Semaphore semantics


The documentation for this class was generated from the following file:
Generated on Tue Aug 27 07:43:14 2002 for ZThread by doxygen1.2.17