ACE_Thread_Mutex Class Reference

ACE_Thread_Mutex wrapper (only valid for threads in the same process). More...

#include <Thread_Mutex.h>

List of all members.

Public Member Functions
	ACE_Thread_Mutex (const ACE_TCHAR *name=0, ACE_mutexattr_t *attributes=0)
	Constructor.
	~ACE_Thread_Mutex (void)
	Implicitly destroy the mutex.
int	remove (void)
int	acquire (void)
	Acquire lock ownership (wait on queue if necessary).
int	acquire (ACE_Time_Value &tv)
int	acquire (ACE_Time_Value *tv)
int	tryacquire (void)
int	release (void)
	Release lock and unblock a thread at head of queue.
int	acquire_read (void)
int	acquire_write (void)
int	tryacquire_read (void)
int	tryacquire_write (void)
int	tryacquire_write_upgrade (void)
const ACE_thread_mutex_t &	lock (void) const
	Return the underlying mutex.
void	dump (void) const
	Dump the state of an object.
Public Attributes
	ACE_ALLOC_HOOK_DECLARE
	Declare the dynamic allocation hooks.
ACE_thread_mutex_t	lock_
	Mutex type that supports single-process locking efficiently.
bool	removed_
Private Member Functions
void	operator= (const ACE_Thread_Mutex &)
	ACE_Thread_Mutex (const ACE_Thread_Mutex &)
Friends
class	ACE_Condition_Thread_Mutex

---

Detailed Description

ACE_Thread_Mutex wrapper (only valid for threads in the same process).

This implementation is optimized for locking threads that are in the same process. It maps to <CRITICAL_SECTION>s on NT and <ACE_mutex_t> with <type> set to <USYNC_THREAD> on UNIX. ACE_Thread_Mutex is recursive on some platforms (like Win32). However, on most platforms (like Solaris) it is not recursive. To be totally safe and portable, developers should use ACE_Recursive_Thread_Mutex when they need a recursive mutex.

Definition at line 50 of file Thread_Mutex.h.

---

Constructor & Destructor Documentation

ACE_Thread_Mutex::ACE_Thread_Mutex	(	const ACE_TCHAR *	name = 0,
		ACE_mutexattr_t *	attributes = 0
	)

Constructor.

ACE_Thread_Mutex::~ACE_Thread_Mutex

(

void

)

Implicitly destroy the mutex.

ACE_Thread_Mutex::ACE_Thread_Mutex

(

const ACE_Thread_Mutex &

)

[private]

---

Member Function Documentation

int ACE_Thread_Mutex::acquire

(

ACE_Time_Value *

tv

)

If tv == 0 the call <acquire()> directly. Otherwise, Block the thread until we acquire the mutex or until tv times out, in which case -1 is returned with 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.

Definition at line 64 of file Thread_Mutex.inl.

{
  // ACE_TRACE ("ACE_Thread_Mutex::acquire");
  return ACE_OS::thread_mutex_lock (&this->lock_, tv);
}

int ACE_Thread_Mutex::acquire

(

ACE_Time_Value &

tv

)

Block the thread until we acquire the mutex or until tv times out, in which case -1 is returned with 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.

Definition at line 57 of file Thread_Mutex.inl.

{
  // ACE_TRACE ("ACE_Thread_Mutex::acquire");
  return ACE_OS::thread_mutex_lock (&this->lock_, tv);
}

int ACE_Thread_Mutex::acquire

(

void

)

Acquire lock ownership (wait on queue if necessary).

Definition at line 50 of file Thread_Mutex.inl.

{
// ACE_TRACE ("ACE_Thread_Mutex::acquire");
  return ACE_OS::thread_mutex_lock (&this->lock_);
}

int ACE_Thread_Mutex::acquire_read

(

void

)

Acquire mutex ownership. This calls acquire() and is only here to make the ACE_Thread_Mutex interface consistent with the other synchronization APIs.

Definition at line 15 of file Thread_Mutex.inl.

{
// ACE_TRACE ("ACE_Thread_Mutex::acquire_read");
  return ACE_OS::thread_mutex_lock (&this->lock_);
}

int ACE_Thread_Mutex::acquire_write

(

void

)

Acquire mutex ownership. This calls acquire() and is only here to make the ACE_Thread_Mutex interface consistent with the other synchronization APIs.

Definition at line 22 of file Thread_Mutex.inl.

{
// ACE_TRACE ("ACE_Thread_Mutex::acquire_write");
  return ACE_OS::thread_mutex_lock (&this->lock_);
}

void ACE_Thread_Mutex::dump

(

void

)

const

Dump the state of an object.

const ACE_thread_mutex_t & ACE_Thread_Mutex::lock

(

void

)

const

Return the underlying mutex.

Definition at line 8 of file Thread_Mutex.inl.

{
// ACE_TRACE ("ACE_Thread_Mutex::lock");
  return this->lock_;
}

void ACE_Thread_Mutex::operator=

(

const ACE_Thread_Mutex &

)

[private]

int ACE_Thread_Mutex::release

(

void

)

Release lock and unblock a thread at head of queue.

Definition at line 78 of file Thread_Mutex.inl.

{
// ACE_TRACE ("ACE_Thread_Mutex::release");
  return ACE_OS::thread_mutex_unlock (&this->lock_);
}

int ACE_Thread_Mutex::remove

(

void

)

Explicitly destroy the mutex. Note that only one thread should call this method since it doesn't protect against race conditions.

Definition at line 85 of file Thread_Mutex.inl.

{
// ACE_TRACE ("ACE_Thread_Mutex::remove");
  int result = 0;
  if (!this->removed_)
    {
      this->removed_ = true;
      result = ACE_OS::thread_mutex_destroy (&this->lock_);
    }
  return result;
}

int ACE_Thread_Mutex::tryacquire

(

void

)

Conditionally acquire lock (i.e., don't wait on queue). Returns -1 on failure. If we "failed" because someone else already had the lock, errno is set to EBUSY.

Definition at line 71 of file Thread_Mutex.inl.

{
// ACE_TRACE ("ACE_Thread_Mutex::tryacquire");
  return ACE_OS::thread_mutex_trylock (&this->lock_);
}

int ACE_Thread_Mutex::tryacquire_read

(

void

)

Conditionally acquire mutex (i.e., won't block). This calls tryacquire() and is only here to make the ACE_Thread_Mutex 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.

Definition at line 29 of file Thread_Mutex.inl.

{
// ACE_TRACE ("ACE_Thread_Mutex::tryacquire_read");
  return ACE_OS::thread_mutex_trylock (&this->lock_);
}

int ACE_Thread_Mutex::tryacquire_write

(

void

)

Conditionally acquire mutex (i.e., won't block). This calls tryacquire() and is only here to make the ACE_Thread_Mutex 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.

Definition at line 36 of file Thread_Mutex.inl.

{
// ACE_TRACE ("ACE_Thread_Mutex::tryacquire_write");
  return ACE_OS::thread_mutex_trylock (&this->lock_);
}

int ACE_Thread_Mutex::tryacquire_write_upgrade

(

void

)

This is only here to make the ACE_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 43 of file Thread_Mutex.inl.

{
// ACE_TRACE ("ACE_Thread_Mutex::tryacquire_write_upgrade");
  return 0;
}

---

Friends And Related Function Documentation

friend class ACE_Condition_Thread_Mutex [friend]

Definition at line 52 of file Thread_Mutex.h.

---

Member Data Documentation

ACE_Thread_Mutex::ACE_ALLOC_HOOK_DECLARE

Declare the dynamic allocation hooks.

Definition at line 147 of file Thread_Mutex.h.

ACE_thread_mutex_t ACE_Thread_Mutex::lock_

Mutex type that supports single-process locking efficiently.

Definition at line 151 of file Thread_Mutex.h.

bool ACE_Thread_Mutex::removed_

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...

Definition at line 158 of file Thread_Mutex.h.

---

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

• Thread_Mutex.h
• Thread_Mutex.inl