#include <ace/Local_Tokens.h>
class ACE_Mutex_Token : public ACE_Tokens {
public:
ACE_Mutex_Token (const ASYS_TCHAR* name);
virtual ~ACE_Mutex_Token (void);
virtual int acquire ( ACE_TPQ_Entry *caller, int ignore_deadlock, int notify );
virtual int tryacquire (ACE_TPQ_Entry *caller);
virtual int renew (ACE_TPQ_Entry *caller, int requeue_position);
virtual int release (ACE_TPQ_Entry *caller);
void dump (void) const;
virtual int type (void) const;
virtual int owners (OWNER_STACK &o, const ASYS_TCHAR *id);
virtual int is_waiting_for (const ASYS_TCHAR *id);
virtual int is_owner (const ASYS_TCHAR *id);
private:
ACE_TOKEN_CONST::MUTEX lock_;
};
public: 7. ACE_Token_Proxy 8. ACE_Null_Token : public ACE_Token_Proxy 9. ACE_Local_Mutex : public ACE_Token_Proxy *. ACE_Local_RLock : public ACE_Local_Mutex &. ACE_Local_WLock : public ACE_Local_Mutex private: 1. ACE_TOKEN_CONST 3. ACE_TPQ_Entry b. ACE_TSS_TPQ_Entry c. ACE_TPQ_Iterator 4. ACE_Token_Proxy_Queue 5. ACE_Tokens 6. ACE_Mutex_Token : public ACE_Tokens 12. ACE_RW_Token : public ACE_Tokens a. ACE_Token_Name
Note that the locking classes defined in this file are *not*
intended to be used as general-purpose synchronization
mechanisms, such as mutexes or semaphores. Instead, you should
use the ACE_Recursive_Thread_Mutex
, ACE_Thread_Mutex
,
ACE_Thread_Semaphore
, etc., that are defined in
$ACE_ROOT/ace/Synch.h and $ACE_ROOT/ace/Synch_T.h or the
ACE_Token
that's defined in $ACE_ROOT/ace/Token.h.
virtual int acquire (
ACE_TPQ_Entry *caller,
int ignore_deadlock,
int notify
);
ACE_Log_Msg::errnum
as
the reason. If errnum == EWOULDBLOCK, and notify == 1,
ACE_Token_Proxy::sleep_hook
has been called on the current
owner of the token. If ignore_deadlock is passed as 1 and errnum
== EDEADLK, then deadlock was detected via ace_token_manager.
virtual int tryacquire (ACE_TPQ_Entry *caller);
virtual int renew (ACE_TPQ_Entry *caller, int requeue_position);
requeue_position
==
-1 and there are other threads waiting to obtain the token we are
queued at the end of the list of waiters. If requeue_position
> -1 then it indicates how many entries to skip over before
inserting our thread into the list of waiters (e.g.,
requeue_position
== 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... Returns 0 on
success, -1 on failure with ACE_Log_Msg::errnum
as the reason.
If errnum == EWOULDBLOCK, and notify == 1,
ACE_Token_Proxy::sleep_hook
has been called on the current
owner of the token.
virtual int release (ACE_TPQ_Entry *caller);
void dump (void) const;
virtual int type (void) const;
virtual int owners (OWNER_STACK &o, const ASYS_TCHAR *id);
id
is non-zero, returns 1 if id is an owner.
virtual int is_waiting_for (const ASYS_TCHAR *id);
id
is waiting for this token. 0 otherwise.
virtual int is_owner (const ASYS_TCHAR *id);
id
is an owner of this token. 0 otherwise.
kdorn@erlh.siemens.de
,
Douglas C. Schmidt schmidt@cs.wustl.edu
, and
Tim Harrison harrison@cs.wustl.edu