ACE_Token Class Reference

Class that acquires, renews, and releases a synchronization token that is serviced in strict FIFO/LIFO ordering and that also supports (1) recursion and (2) readers/writer semantics. More...

#include <Token.h>

Collaboration diagram for ACE_Token:

[legend]List of all members.

Public Types
enum	QUEUEING_STRATEGY { FIFO = -1, LIFO = 0 }
Public Member Functions
	ACE_Token (const ACE_TCHAR *name=0, void *=0)
	Constructor.
virtual	~ACE_Token (void)
	Destructor.
int	queueing_strategy (void)
	Retrieve the current queueing strategy.
void	queueing_strategy (int queueing_strategy)
	Set the queueing strategy.
int	acquire (void(*sleep_hook)(void *), void *arg=0, ACE_Time_Value *timeout=0)
int	acquire (ACE_Time_Value *timeout=0)
virtual void	sleep_hook (void)
int	renew (int requeue_position=0, ACE_Time_Value *timeout=0)
int	tryacquire (void)
int	remove (void)
	Shuts down the ACE_Token instance.
int	release (void)
int	acquire_read (void)
int	acquire_read (void(*sleep_hook)(void *), void *arg=0, ACE_Time_Value *timeout=0)
int	acquire_write (void)
	Calls acquire().
int	acquire_write (void(*sleep_hook)(void *), void *arg=0, ACE_Time_Value *timeout=0)
	Calls acquire().
int	tryacquire_read (void)
	Lower priority try_acquire().
int	tryacquire_write (void)
	Just calls .
int	tryacquire_write_upgrade (void)
	Assumes the caller has acquired the token and returns 0.
int	waiters (void)
ACE_thread_t	current_owner (void)
	Return the id of the current thread that owns the token.
void	dump (void) const
	Dump the state of an object.
Public Attributes
	ACE_ALLOC_HOOK_DECLARE
	Declare the dynamic allocation hooks.
Private Types
enum	ACE_Token_Op_Type { READ_TOKEN = 1, WRITE_TOKEN }
Private Member Functions
int	shared_acquire (void(*sleep_hook_func)(void *), void *arg, ACE_Time_Value *timeout, ACE_Token_Op_Type op_type)
	Implements the and methods above.
void	wakeup_next_waiter (void)
	Wake next in line for ownership.
Private Attributes
ACE_Token_Queue	writers_
	A queue of writer threads.
ACE_Token_Queue	readers_
	A queue of reader threads.
ACE_Thread_Mutex	lock_
	ACE_Thread_Mutex used to lock internal data structures.
ACE_thread_t	owner_
	Current owner of the token.
int	in_use_
int	waiters_
	Number of waiters.
int	nesting_level_
	Current nesting level.
ACE_Condition_Attributes	attributes_
	The attributes for the condition variables, optimizes lock time.
int	queueing_strategy_
	Queueing strategy, LIFO/FIFO.

---

Detailed Description

Class that acquires, renews, and releases a synchronization token that is serviced in strict FIFO/LIFO ordering and that also supports (1) recursion and (2) readers/writer semantics.

This class is a more general-purpose synchronization mechanism than many native OS mutexes. For example, it implements "recursive mutex" semantics, where a thread that owns the token can reacquire it without deadlocking. If the same thread calls multiple times, however, it must call an equal number of times before the token is actually released. Threads that are blocked awaiting the token are serviced in strict FIFO/LIFO order as other threads release the token (Solaris and Pthread mutexes don't strictly enforce an acquisition order). There are two lists within the class. Write acquires always have higher priority over read acquires. Which means, if you use both write/read operations, care must be taken to avoid starvation on the readers. Notice that the read/write acquire operations do not have the usual semantic of reader/writer locks. Only one reader can acquire the token at a time (which is different from the usual reader/writer locks where several readers can acquire a lock at the same time as long as there is no writer waiting for the lock). We choose the names to (1) borrow the semantic to give writers higher priority and (2) support a common interface for all locking classes in ACE.

Definition at line 76 of file Token.h.

---

Member Enumeration Documentation

enum ACE_Token::ACE_Token_Op_Type [private]

Enumeration values: READ_TOKEN  WRITE_TOKEN  Definition at line 257 of file Token.h. { READ_TOKEN = 1, WRITE_TOKEN };

enum ACE_Token::QUEUEING_STRATEGY

Available queueing strategies. Enumeration values: FIFO  FIFO, First In, First Out. LIFO  LIFO, Last In, First Out. Definition at line 83 of file Token.h. { /// FIFO, First In, First Out. FIFO = -1, /// LIFO, Last In, First Out LIFO = 0 };

---

Constructor & Destructor Documentation

ACE_Token::ACE_Token (  const ACE_TCHAR *  name = 0, void *  = 0 )

Constructor. Definition at line 166 of file Token.cpp. References ACE_TCHAR, FIFO, and queueing_strategy_. : lock_ (name, (ACE_mutexattr_t *) any), owner_ (ACE_OS::NULL_thread), in_use_ (0), waiters_ (0), nesting_level_ (0), attributes_ (USYNC_THREAD), queueing_strategy_ (FIFO) { // ACE_TRACE ("ACE_Token::ACE_Token"); }

ACE_Token::~ACE_Token (  void   )  [virtual]

Destructor. Definition at line 178 of file Token.cpp. References ACE_TRACE. { ACE_TRACE ("ACE_Token::~ACE_Token"); }

---

Member Function Documentation

int ACE_Token::acquire (  ACE_Time_Value *  timeout = 0  )

This behaves just like the previous method, except that it invokes the virtual function called that can be overridden by a subclass of ACE_Token. Definition at line 338 of file Token.cpp. References ACE_TRACE, shared_acquire(), and WRITE_TOKEN. { ACE_TRACE ("ACE_Token::acquire"); return this->shared_acquire (0, 0, timeout, ACE_Token::WRITE_TOKEN); }

int ACE_Token::acquire (  void(*  sleep_hook)(void *), void *  arg = 0, ACE_Time_Value *  timeout = 0 )

Acquire the token, sleeping until it is obtained or until the expiration of , which is treated as "absolute" time. If some other thread currently holds the token then is called before our thread goes to sleep. This can be used by the requesting thread to unblock a token-holder that is sleeping, e.g., by means of writing to a pipe (the ACE ACE_Reactor uses this functionality). Return values: 0 if acquires without calling 1 if is called. 2 if the token is signaled. -1 if failure or timeout occurs (if timeout occurs errno == ETIME) If == <&ACE_Time_Value::zero> then acquire has polling semantics (and does *not* call ). Definition at line 348 of file Token.cpp. References ACE_TRACE, shared_acquire(), and WRITE_TOKEN. { ACE_TRACE ("ACE_Token::acquire"); return this->shared_acquire (sleep_hook_func, arg, timeout, ACE_Token::WRITE_TOKEN); }

ACE_INLINE int ACE_Token::acquire_read (  void(*  sleep_hook)(void *), void *  arg = 0, ACE_Time_Value *  timeout = 0 )

Behaves like acquire() but at a lower priority. It should probably be called acquire_yield() since the semantics aren't really what's commonly expected for readers/writer locks. See the class documentation above for more details. Definition at line 86 of file Token.inl. References ACE_TRACE, READ_TOKEN, and shared_acquire(). { ACE_TRACE ("ACE_Token::acquire_read"); return this->shared_acquire (sleep_hook_func, arg, timeout, ACE_Token::READ_TOKEN); }

ACE_INLINE int ACE_Token::acquire_read (  void   )

Behaves like acquire() but at a lower priority. It should probably be called acquire_yield() since the semantics aren't really what's commonly expected for readers/writer locks. See the class documentation above for more details. Definition at line 62 of file Token.inl. References ACE_TRACE, READ_TOKEN, and shared_acquire(). { ACE_TRACE ("ACE_Token::acquire_read"); return this->shared_acquire (0, 0, 0, ACE_Token::READ_TOKEN); }

ACE_INLINE int ACE_Token::acquire_write (  void(*  sleep_hook)(void *), void *  arg = 0, ACE_Time_Value *  timeout = 0 )

Calls acquire(). Definition at line 110 of file Token.inl. References ACE_TRACE, shared_acquire(), and WRITE_TOKEN. { ACE_TRACE ("ACE_Token::acquire_write"); return this->shared_acquire (sleep_hook_func, arg, timeout, ACE_Token::WRITE_TOKEN); }

ACE_INLINE int ACE_Token::acquire_write (  void   )

Calls acquire(). Definition at line 70 of file Token.inl. References ACE_TRACE, shared_acquire(), and WRITE_TOKEN. { ACE_TRACE ("ACE_Token::acquire_write"); return this->shared_acquire (0, 0, 0, ACE_Token::WRITE_TOKEN); }

ACE_INLINE ACE_thread_t ACE_Token::current_owner (  void   )

Return the id of the current thread that owns the token. Definition at line 53 of file Token.inl. References ACE_GUARD_RETURN, and ACE_TRACE. { ACE_TRACE ("ACE_Token::current_owner"); ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, this->owner_); return this->owner_; }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL void ACE_Token::dump (  void   )  const

Dump the state of an object. Definition at line 26 of file Token.cpp. References ACE_BEGIN_DUMP, ACE_DEBUG, ACE_END_DUMP, ACE_LIB_TEXT, ACE_TRACE, and LM_DEBUG. Referenced by release(), renew(), and shared_acquire(). { #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_Token::dump"); ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\nthread = %d"), ACE_Thread::self ())); // @@ Is there a portable way to do this? // ACE_DEBUG ((LM_DEBUG, "\nowner_ = %d", (long) this->owner_)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\nowner_ addr = %x"), &this->owner_)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\nwaiters_ = %d"), this->waiters_)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\nin_use_ = %d"), this->in_use_)); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\nnesting level = %d"), this->nesting_level_)); ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); #endif /* ACE_HAS_DUMP */ }

ACE_INLINE void ACE_Token::queueing_strategy (  int  queueing_strategy  )

Set the queueing strategy. Definition at line 21 of file Token.inl. References queueing_strategy_. { this->queueing_strategy_ = queueing_strategy == -1 ? -1 : 0; }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE int ACE_Token::queueing_strategy (  void   )

Retrieve the current queueing strategy. Definition at line 15 of file Token.inl. References queueing_strategy_. { return this->queueing_strategy_; }

int ACE_Token::release (  void   )

Relinquish the token. If there are any waiters then the next one in line gets it. Definition at line 483 of file Token.cpp. References ACE_GUARD_RETURN, ACE_TRACE, dump(), and wakeup_next_waiter(). { ACE_TRACE ("ACE_Token::release"); ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1); // ACE_ASSERT (ACE_OS::thr_equal (ACE_Thread::self (), this->owner_)); #if defined (DEBUGGING) this->dump (); #endif /* DEBUGGING */ // Nested release... if (this->nesting_level_ > 0) --this->nesting_level_; else { // // Regular release... // // Wakeup waiter. this->wakeup_next_waiter (); } return 0; }

ACE_INLINE int ACE_Token::remove (  void   )

Shuts down the ACE_Token instance. Definition at line 27 of file Token.inl. References ACE_NOTSUP_RETURN, and ACE_TRACE. { ACE_TRACE ("ACE_Token::remove"); // Don't have an implementation for this yet... ACE_NOTSUP_RETURN (-1); }

int ACE_Token::renew (  int  requeue_position = 0, ACE_Time_Value *  timeout = 0 )

An optimized method that efficiently reacquires the token if no other threads are waiting. This is useful for situations where you don't want to degrade the quality of service if there are other threads waiting to get the token. If == -1 and there are other threads waiting to obtain the token we are queued according to the queueing strategy. If > -1 then it indicates how many entries to skip over before inserting our thread into the list of waiters (e.g., == 0 means "insert at front of the queue"). Renew has the rather odd semantics such that if there are other waiting threads it will give up the token even if the nesting_level_ > 1. I'm not sure if this is really the right thing to do (since it makes it possible for shared data to be changed unexpectedly) so use with caution... This method maintians the original token priority. As in , the value is an absolute time. Definition at line 359 of file Token.cpp. References ACE_ASSERT, ACE_GUARD_RETURN, ACE_TRACE, dump(), ETIME, ACE_Token::ACE_Token_Queue::head_, ACE_Token::ACE_Token_Queue::insert_entry(), READ_TOKEN, readers_, ACE_Token::ACE_Token_Queue::remove_entry(), ACE_Token::ACE_Token_Queue_Entry::runable_, ACE_Thread::self(), ACE_OS::thr_equal(), ACE_Token::ACE_Token_Queue_Entry::thread_id_, ACE_Token::ACE_Token_Queue_Entry::wait(), wakeup_next_waiter(), WRITE_TOKEN, and writers_. { ACE_TRACE ("ACE_Token::renew"); ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1); #if defined (DEBUGGING) this->dump (); #endif /* DEBUGGING */ // ACE_ASSERT (ACE_OS::thr_equal (ACE_Thread::self (), this->owner_)); // Check to see if there are any waiters worth giving up the lock // for. // If no writers and either we are a writer or there are no readers. if (this->writers_.head_ == 0 && (this->in_use_ == ACE_Token::WRITE_TOKEN || this->readers_.head_ == 0)) // Immediate return. return 0; // We've got to sleep until we get the token again. // Determine which queue should this thread go to. ACE_Token::ACE_Token_Queue *this_threads_queue = this->in_use_ == ACE_Token::READ_TOKEN ? &this->readers_ : &this->writers_; ACE_Token::ACE_Token_Queue_Entry my_entry (this->lock_, this->owner_); this_threads_queue->insert_entry (my_entry, // if requeue_position == 0 then we want to go next, // otherwise use the queueing strategy, which might also // happen to be 0. requeue_position == 0 ? 0 : this->queueing_strategy_); ++this->waiters_; // Remember nesting level... int const save_nesting_level_ = this->nesting_level_; // Reset state for new owner. this->nesting_level_ = 0; // Wakeup waiter. this->wakeup_next_waiter (); int timed_out = 0; int error = 0; // Sleep until we've got the token (ignore signals). do { int result = my_entry.wait (timeout, this->lock_); if (result == -1) { // Note, this should obey whatever thread-specific interrupt // policy is currently in place... if (errno == EINTR) continue; #if defined (DEBUGGING) cerr << '(' << ACE_Thread::self () << ')' << " renew: " << (errno == ETIME ? "timed out" : "error occurred") << endl; #endif /* DEBUGGING */ // We come here if a timeout occurs or some serious // ACE_Condition object error. if (errno == ETIME) timed_out = 1; else error = 1; // Stop the loop. break; } } while (!ACE_OS::thr_equal (my_entry.thread_id_, this->owner_)); // Do this always and irrespective of the result of wait(). --this->waiters_; this_threads_queue->remove_entry (&my_entry); #if defined (DEBUGGING) cerr << '(' << ACE_Thread::self () << ')' << " acquire (UNBLOCKED)" << endl; #endif /* DEBUGGING */ // If timeout occured if (timed_out) { // This thread was still selected to own the token. if (my_entry.runable_) { // Wakeup next waiter since this thread timed out. this->wakeup_next_waiter (); } // Return error. return -1; } else if (error) { // Return error. return -1; } // If this is a normal wakeup, this thread should be runnable. ACE_ASSERT (my_entry.runable_); // Reinstate nesting level. this->nesting_level_ = save_nesting_level_; return 0; }

int ACE_Token::shared_acquire (  void(*  sleep_hook_func)(void *), void *  arg, ACE_Time_Value *  timeout, ACE_Token_Op_Type  op_type )  [private]

Implements the and methods above. Definition at line 184 of file Token.cpp. References ACE_ASSERT, ACE_GUARD_RETURN, ACE_thread_t, ACE_TRACE, dump(), ETIME, ACE_Token::ACE_Token_Queue::insert_entry(), READ_TOKEN, readers_, ACE_Token::ACE_Token_Queue::remove_entry(), ACE_Token::ACE_Token_Queue_Entry::runable_, ACE_Time_Value::sec(), ACE_Thread::self(), sleep_hook(), ACE_OS::thr_equal(), ACE_Time_Value::usec(), ACE_Token::ACE_Token_Queue_Entry::wait(), wakeup_next_waiter(), and writers_. Referenced by acquire(), acquire_read(), acquire_write(), tryacquire(), tryacquire_read(), and tryacquire_write(). { ACE_TRACE ("ACE_Token::shared_acquire"); ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1); #if defined (DEBUGGING) this->dump (); #endif /* DEBUGGING */ ACE_thread_t thr_id = ACE_Thread::self (); // Nobody holds the token. if (!this->in_use_) { // Its mine! this->in_use_ = op_type; this->owner_ = thr_id; return 0; } // // Someone already holds the token. // // Check if it is us. if (ACE_OS::thr_equal (thr_id, this->owner_)) { ++this->nesting_level_; return 0; } // Do a quick check for "polling" behavior. if (timeout != 0 && timeout->sec () == 0 && timeout->usec () == 0) { errno = ETIME; return -1; } // // We've got to sleep until we get the token. // // Which queue we should end up in... ACE_Token_Queue *queue = (op_type == ACE_Token::READ_TOKEN ? &this->readers_ : &this->writers_); // Allocate queue entry on stack. This works since we don't exit // this method's activation record until we've got the token. ACE_Token::ACE_Token_Queue_Entry my_entry (this->lock_, thr_id, this->attributes_); queue->insert_entry (my_entry, this->queueing_strategy_); ++this->waiters_; // Execute appropriate <sleep_hook> callback. (@@ should these // methods return a success/failure status, and if so, what should // we do with it?) int ret = 0; if (sleep_hook_func) { (*sleep_hook_func) (arg); ++ret; } else { // Execute virtual method. this->sleep_hook (); ++ret; } int timed_out = 0; int error = 0; // Sleep until we've got the token (ignore signals). do { int result = my_entry.wait (timeout, this->lock_); if (result == -1) { // Note, this should obey whatever thread-specific interrupt // policy is currently in place... if (errno == EINTR) continue; #if defined (DEBUGGING) cerr << '(' << ACE_Thread::self () << ')' << " acquire: " << (errno == ETIME ? "timed out" : "error occurred") << endl; #endif /* DEBUGGING */ // We come here if a timeout occurs or some serious // ACE_Condition object error. if (errno == ETIME) timed_out = 1; else error = 1; // Stop the loop. break; } } while (!ACE_OS::thr_equal (thr_id, this->owner_)); // Do this always and irrespective of the result of wait(). --this->waiters_; queue->remove_entry (&my_entry); #if defined (DEBUGGING) cerr << '(' << ACE_Thread::self () << ')' << " acquire (UNBLOCKED)" << endl; #endif /* DEBUGGING */ // If timeout occured if (timed_out) { // This thread was still selected to own the token. if (my_entry.runable_) { // Wakeup next waiter since this thread timed out. this->wakeup_next_waiter (); } // Return error. return -1; } else if (error) { // Return error. return -1; } // If this is a normal wakeup, this thread should be runnable. ACE_ASSERT (my_entry.runable_); return ret; }

void ACE_Token::sleep_hook (  void   )  [virtual]

This should be overridden by a subclass to define the appropriate behavior before goes to sleep. By default, this is a no-op... Definition at line 332 of file Token.cpp. References ACE_TRACE. Referenced by shared_acquire(). { ACE_TRACE ("ACE_Token::sleep_hook"); }

ACE_INLINE int ACE_Token::tryacquire (  void   )

Become interface-compliant with other lock mechanisms (implements a non-blocking ). Definition at line 35 of file Token.inl. References ACE_TRACE, shared_acquire(), and WRITE_TOKEN. { ACE_TRACE ("ACE_Token::tryacquire"); return this->shared_acquire (0, 0, (ACE_Time_Value *) &ACE_Time_Value::zero, ACE_Token::WRITE_TOKEN); }

ACE_INLINE int ACE_Token::tryacquire_read (  void   )

Lower priority try_acquire(). Definition at line 78 of file Token.inl. References ACE_TRACE, READ_TOKEN, and shared_acquire(). { ACE_TRACE ("ACE_Token::tryacquire_read"); return this->shared_acquire (0, 0, (ACE_Time_Value *) &ACE_Time_Value::zero, ACE_Token::READ_TOKEN); }

ACE_INLINE int ACE_Token::tryacquire_write (  void   )

Just calls . Definition at line 95 of file Token.inl. References ACE_TRACE, shared_acquire(), and WRITE_TOKEN. { ACE_TRACE ("ACE_Token::tryacquire_write"); return this->shared_acquire (0, 0, (ACE_Time_Value *) &ACE_Time_Value::zero, ACE_Token::WRITE_TOKEN); }

ACE_INLINE int ACE_Token::tryacquire_write_upgrade (  void   )

Assumes the caller has acquired the token and returns 0. Definition at line 103 of file Token.inl. References ACE_TRACE. { ACE_TRACE ("ACE_Token::tryacquire_write_upgrade"); return 0; }

ACE_INLINE int ACE_Token::waiters (  void   )

Return the number of threads that are currently waiting to get the token. Definition at line 43 of file Token.inl. References ACE_GUARD_RETURN, and ACE_TRACE. { ACE_TRACE ("ACE_Token::waiters"); ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1); int const ret = this->waiters_; return ret; }

void ACE_Token::wakeup_next_waiter (  void   )  [private]

Wake next in line for ownership. Definition at line 511 of file Token.cpp. References ACE_TRACE, ACE_Token::ACE_Token_Queue::head_, READ_TOKEN, readers_, ACE_Token::ACE_Token_Queue_Entry::runable_, ACE_Token::ACE_Token_Queue_Entry::signal(), ACE_Token::ACE_Token_Queue_Entry::thread_id_, WRITE_TOKEN, and writers_. Referenced by release(), renew(), and shared_acquire(). { ACE_TRACE ("ACE_Token::wakeup_next_waiter"); // Reset state for new owner. this->owner_ = ACE_OS::NULL_thread; this->in_use_ = 0; // Any waiters... if (this->writers_.head_ == 0 && this->readers_.head_ == 0) { // No more waiters... return; } // Wakeup next waiter. ACE_Token_Queue *queue = 0; // Writer threads get priority to run first. if (this->writers_.head_ != 0) { this->in_use_ = ACE_Token::WRITE_TOKEN; queue = &this->writers_; } else { this->in_use_ = ACE_Token::READ_TOKEN; queue = &this->readers_; } // Wake up waiter and make it runable. queue->head_->runable_ = 1; queue->head_->signal (); this->owner_ = queue->head_->thread_id_; }

---

Member Data Documentation

ACE_Token::ACE_ALLOC_HOOK_DECLARE

Declare the dynamic allocation hooks. Definition at line 217 of file Token.h.

ACE_Condition_Attributes ACE_Token::attributes_ [private]

The attributes for the condition variables, optimizes lock time. Definition at line 314 of file Token.h.

int ACE_Token::in_use_ [private]

Some thread (i.e., ) is using the token. We need this extra variable to deal with POSIX pthreads madness... Definition at line 305 of file Token.h.

ACE_Thread_Mutex ACE_Token::lock_ [private]

ACE_Thread_Mutex used to lock internal data structures. Definition at line 298 of file Token.h.

int ACE_Token::nesting_level_ [private]

Current nesting level. Definition at line 311 of file Token.h.

ACE_thread_t ACE_Token::owner_ [private]

Current owner of the token. Definition at line 301 of file Token.h.

int ACE_Token::queueing_strategy_ [private]

Queueing strategy, LIFO/FIFO. Definition at line 317 of file Token.h. Referenced by ACE_Token(), and queueing_strategy().

ACE_Token_Queue ACE_Token::readers_ [private]

A queue of reader threads. Definition at line 295 of file Token.h. Referenced by renew(), shared_acquire(), and wakeup_next_waiter().

int ACE_Token::waiters_ [private]

Number of waiters. Definition at line 308 of file Token.h.

ACE_Token_Queue ACE_Token::writers_ [private]

A queue of writer threads. Definition at line 292 of file Token.h. Referenced by renew(), shared_acquire(), and wakeup_next_waiter().

---

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

• Token.h
• Token.cpp
• Token.inl

---