#include <Recursive_Thread_Mutex.h>
Collaboration diagram for ACE_Recursive_Thread_Mutex:
Public Member Functions | |
ACE_Recursive_Thread_Mutex (const ACE_TCHAR *name=0, ACE_mutexattr_t *arg=0) | |
Initialize a recursive mutex. | |
~ACE_Recursive_Thread_Mutex (void) | |
Implicitly release a recursive mutex. | |
int | remove (void) |
int | acquire (void) |
int | acquire (ACE_Time_Value &tv) |
int | acquire (ACE_Time_Value *tv) |
int | tryacquire (void) |
int | acquire_read (void) |
int | acquire_write (void) |
int | tryacquire_read (void) |
int | tryacquire_write (void) |
int | tryacquire_write_upgrade (void) |
int | release (void) |
ACE_thread_t | get_thread_id (void) |
Return the id of the thread that currently owns the mutex. | |
int | get_nesting_level (void) |
ACE_recursive_thread_mutex_t & | mutex (void) |
Returns a reference to the recursive mutex;. | |
ACE_thread_mutex_t & | get_nesting_mutex (void) |
Returns a reference to the recursive mutex's internal mutex;. | |
void | dump (void) const |
Dump the state of an object. | |
Public Attributes | |
ACE_ALLOC_HOOK_DECLARE | |
Declare the dynamic allocation hooks. | |
Protected Member Functions | |
void | set_thread_id (ACE_thread_t t) |
Protected Attributes | |
ACE_recursive_thread_mutex_t | lock_ |
Recursive mutex. | |
int | removed_ |
Private Member Functions | |
void | operator= (const ACE_Recursive_Thread_Mutex &) |
ACE_Recursive_Thread_Mutex (const ACE_Recursive_Thread_Mutex &) |
Definition at line 41 of file Recursive_Thread_Mutex.h.
|
Initialize a recursive mutex.
Definition at line 27 of file Recursive_Thread_Mutex.cpp. References ACE_ERROR, ACE_LIB_TEXT, ACE_TCHAR, LM_ERROR, and ACE_OS::recursive_mutex_init().
00029 : removed_ (0) 00030 { 00031 // ACE_TRACE ("ACE_Recursive_Thread_Mutex::ACE_Recursive_Thread_Mutex"); 00032 if (ACE_OS::recursive_mutex_init (&this->lock_, 00033 name, 00034 arg) == -1) 00035 ACE_ERROR ((LM_ERROR, 00036 ACE_LIB_TEXT ("%p\n"), 00037 ACE_LIB_TEXT ("recursive_mutex_init"))); 00038 } |
|
Implicitly release a recursive mutex.
Definition at line 40 of file Recursive_Thread_Mutex.cpp. References remove().
00041 { 00042 // ACE_TRACE ("ACE_Recursive_Thread_Mutex::~ACE_Recursive_Thread_Mutex"); 00043 this->remove (); 00044 } |
|
Definition at line 111 of file Recursive_Thread_Mutex.cpp.
00112 { 00113 } |
|
If == 0 the call <acquire()> directly. Otherwise, Block the thread until we acquire the mutex or until times out, in which case -1 is returned with == . 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. Definition at line 59 of file Recursive_Thread_Mutex.inl. References ACE_OS::recursive_mutex_lock().
00060 { 00061 return ACE_OS::recursive_mutex_lock (&this->lock_, tv); 00062 } |
|
Block the thread until we acquire the mutex or until tv times out, in which case -1 is returned with == . 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. Definition at line 53 of file Recursive_Thread_Mutex.inl. References ACE_OS::recursive_mutex_lock().
00054 { 00055 return ACE_OS::recursive_mutex_lock (&this->lock_, tv); 00056 } |
|
Acquire a recursive mutex (will increment the nesting level and not deadmutex if the owner of the mutex calls this method more than once). Definition at line 35 of file Recursive_Thread_Mutex.inl. References ACE_OS::recursive_mutex_lock(). Referenced by ACE_Log_Msg::acquire(), acquire_read(), and acquire_write().
00036 { 00037 return ACE_OS::recursive_mutex_lock (&this->lock_); 00038 } |
|
Acquire mutex ownership. This calls and is only here to make the interface consistent with the other synchronization APIs. Definition at line 65 of file Recursive_Thread_Mutex.inl. References acquire().
00066 { 00067 return this->acquire (); 00068 } |
|
Acquire mutex ownership. This calls and is only here to make the interface consistent with the other synchronization APIs. Definition at line 71 of file Recursive_Thread_Mutex.inl. References acquire().
00072 { 00073 return this->acquire (); 00074 } |
|
Dump the state of an object.
Definition at line 116 of file Recursive_Thread_Mutex.cpp. References ACE_BEGIN_DUMP, ACE_DEBUG, ACE_END_DUMP, and LM_DEBUG. Referenced by ACE_Future_Rep< T >::dump().
|
|
Return the nesting level of the recursion. When a thread has acquired the mutex for the first time, the nesting level == 1. The nesting level is incremented every time the thread acquires the mutex recursively. Note that if the ACE_HAS_RECURSIVE_MUTEXES macro is enabled then this method may return -1 on platforms that do not expose the internal count. Definition at line 82 of file Recursive_Thread_Mutex.cpp. References ACE_NOTSUP_RETURN, ACE_OS::mutex_lock(), ACE_OS::mutex_unlock(), and ACE_recursive_thread_mutex_t::nesting_level_.
00083 { 00084 // ACE_TRACE ("ACE_Recursive_Thread_Mutex::get_nesting_level"); 00085 #if defined (ACE_HAS_WINCE) || defined (ACE_VXWORKS) 00086 ACE_NOTSUP_RETURN (-1); 00087 #elif defined (ACE_HAS_RECURSIVE_MUTEXES) 00088 // Nothing inside of a CRITICAL_SECTION object should ever be 00089 // accessed directly. It is documented to change at any time. 00090 # if defined (ACE_WIN64) && !defined(_M_AMD64) 00091 // Things are different on Windows XP 64-bit. However, as of Feb 2006 00092 // Windows XP 64-bit edition on Intel EM64T w/ VC8, LockCount is 00093 // decremented at first acquire and then doesn't change. RecursionCount, 00094 // however, works the same as Win32, below. 00095 return this->lock_.LockCount + 1; 00096 # elif defined (ACE_WIN32) 00097 // This is really a Win32-ism... 00098 return this->lock_.RecursionCount; 00099 # else 00100 ACE_NOTSUP_RETURN (-1); 00101 # endif /* ACE_HAS_RECURSIVE_MUTEXES */ 00102 #else 00103 int nesting_level = 0; 00104 ACE_OS::mutex_lock (&this->lock_.nesting_mutex_); 00105 nesting_level = this->lock_.nesting_level_; 00106 ACE_OS::mutex_unlock (&this->lock_.nesting_mutex_); 00107 return nesting_level; 00108 #endif /* !ACE_HAS_WINCE */ 00109 } |
|
Returns a reference to the recursive mutex's internal mutex;.
Definition at line 14 of file Recursive_Thread_Mutex.inl. References ACE_recursive_thread_mutex_t::nesting_mutex_. Referenced by ACE_Condition< ACE_Recursive_Thread_Mutex >::wait().
00015 { 00016 #if defined (ACE_HAS_RECURSIVE_MUTEXES) 00017 return static_cast<ACE_thread_mutex_t &> (lock_); 00018 #else 00019 return lock_.nesting_mutex_; 00020 #endif /* ACE_HAS_RECURSIVE_MUTEXES */ 00021 } |
|
Return the id of the thread that currently owns the mutex.
Definition at line 62 of file Recursive_Thread_Mutex.cpp. References ACE_thread_t, ENOTSUP, ACE_OS::mutex_lock(), ACE_OS::mutex_unlock(), and ACE_recursive_thread_mutex_t::owner_id_.
00063 { 00064 // ACE_TRACE ("ACE_Recursive_Thread_Mutex::get_thread_id"); 00065 #if defined (ACE_HAS_RECURSIVE_MUTEXES) 00066 // @@ The structure CriticalSection in Win32 doesn't hold the thread 00067 // handle of the thread that owns the lock. However it is still not 00068 // clear at this point how to translate a thread handle to its 00069 // corresponding thread id. 00070 errno = ENOTSUP; 00071 return ACE_OS::NULL_thread; 00072 #else 00073 ACE_thread_t owner_id; 00074 ACE_OS::mutex_lock (&this->lock_.nesting_mutex_); 00075 owner_id = this->lock_.owner_id_; 00076 ACE_OS::mutex_unlock (&this->lock_.nesting_mutex_); 00077 return owner_id; 00078 #endif /* ACE_WIN32 */ 00079 } |
|
Returns a reference to the recursive mutex;.
Definition at line 8 of file Recursive_Thread_Mutex.inl. Referenced by ACE_Condition< ACE_Recursive_Thread_Mutex >::wait().
00009 { 00010 return lock_; 00011 } |
|
|
|
Releases a recursive mutex (will not release mutex until all the nesting level drops to 0, which means the mutex is no longer held). Definition at line 41 of file Recursive_Thread_Mutex.inl. References ACE_OS::recursive_mutex_unlock(). Referenced by ACE_Log_Msg::release().
00042 { 00043 return ACE_OS::recursive_mutex_unlock (&this->lock_); 00044 } |
|
Implicitly release a recursive mutex. Note that only one thread should call this method since it doesn't protect against race conditions. Definition at line 47 of file Recursive_Thread_Mutex.cpp. References ACE_OS::recursive_mutex_destroy(). Referenced by ~ACE_Recursive_Thread_Mutex().
00048 { 00049 // ACE_TRACE ("ACE_Recursive_Thread_Mutex::remove"); 00050 int result = 0; 00051 if (this->removed_ == 0) 00052 { 00053 this->removed_ = 1; 00054 result = ACE_OS::recursive_mutex_destroy (&this->lock_); 00055 } 00056 return result; 00057 } |
|
Definition at line 24 of file Recursive_Thread_Mutex.inl. References ACE_recursive_thread_mutex_t::owner_id_.
|
|
Conditionally acquire a recursive mutex (i.e., won't block). Returns -1 on failure. If we "failed" because someone else already had the lock, is set to . Definition at line 47 of file Recursive_Thread_Mutex.inl. References ACE_OS::recursive_mutex_trylock(). Referenced by tryacquire_read(), and tryacquire_write().
00048 { 00049 return ACE_OS::recursive_mutex_trylock (&this->lock_); 00050 } |
|
Conditionally acquire mutex (i.e., won't block). This calls and is only here to make the interface consistent with the other synchronization APIs. Returns -1 on failure. If we "failed" because someone else already had the lock, is set to . Definition at line 77 of file Recursive_Thread_Mutex.inl. References tryacquire().
00078 { 00079 return this->tryacquire (); 00080 } |
|
Conditionally acquire mutex (i.e., won't block). This calls and is only here to make the interface consistent with the other synchronization APIs. Returns -1 on failure. If we "failed" because someone else already had the lock, is set to . Definition at line 83 of file Recursive_Thread_Mutex.inl. References tryacquire().
00084 { 00085 return this->tryacquire (); 00086 } |
|
This is only here to make the ACE_Recursive_Thread_Mutex interface consistent with the other synchronization APIs. Assumes the caller has already acquired the mutex using one of the above calls, and returns 0 (success) always. Definition at line 89 of file Recursive_Thread_Mutex.inl.
00090 {
00091 return 0;
00092 }
|
|
Declare the dynamic allocation hooks.
Definition at line 163 of file Recursive_Thread_Mutex.h. |
|
Recursive mutex.
Definition at line 170 of file Recursive_Thread_Mutex.h. |
|
Keeps track of whether has been called yet to avoid multiple 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 on the same object, which is a bad idea anyway... Definition at line 177 of file Recursive_Thread_Mutex.h. |