.TH ACE_Thread_Mutex 3 "1 Dec 2001" "ACE" \" -*- nroff -*-
.ad l
.nh
.SH NAME
ACE_Thread_Mutex \- ACE_Thread_Mutex wrapper (only valid for threads in the same process). 
.SH SYNOPSIS
.br
.PP
\fC#include <Synch.h>\fR
.PP
.SS Public Methods

.in +1c
.ti -1c
.RI "\fBACE_Thread_Mutex\fR (const \fBACE_TCHAR\fR *name = 0, ACE_mutexattr_t *attributes = 0)"
.br
.RI "\fIConstructor.\fR"
.ti -1c
.RI "\fB~ACE_Thread_Mutex\fR (void)"
.br
.RI "\fIImplicitly destroy the mutex.\fR"
.ti -1c
.RI "int \fBremove\fR (void)"
.br
.ti -1c
.RI "int \fBacquire\fR (void)"
.br
.RI "\fIAcquire lock ownership (wait on queue if necessary).\fR"
.ti -1c
.RI "int \fBacquire\fR (\fBACE_Time_Value\fR &tv)"
.br
.ti -1c
.RI "int \fBacquire\fR (\fBACE_Time_Value\fR *tv)"
.br
.ti -1c
.RI "int \fBtryacquire\fR (void)"
.br
.ti -1c
.RI "int \fBrelease\fR (void)"
.br
.RI "\fIRelease lock and unblock a thread at head of queue.\fR"
.ti -1c
.RI "int \fBacquire_read\fR (void)"
.br
.ti -1c
.RI "int \fBacquire_write\fR (void)"
.br
.ti -1c
.RI "int \fBtryacquire_read\fR (void)"
.br
.ti -1c
.RI "int \fBtryacquire_write\fR (void)"
.br
.ti -1c
.RI "int \fBtryacquire_write_upgrade\fR (void)"
.br
.ti -1c
.RI "const ACE_thread_mutex_t& \fBlock\fR (void) const"
.br
.RI "\fIReturn the underlying mutex.\fR"
.ti -1c
.RI "void \fBdump\fR (void) const"
.br
.RI "\fIDump the state of an object.\fR"
.in -1c
.SS Public Attributes

.in +1c
.ti -1c
.RI "\fBACE_ALLOC_HOOK_DECLARE\fR"
.br
.RI "\fIDeclare the dynamic allocation hooks.\fR"
.ti -1c
.RI "ACE_thread_mutex_t \fBlock_\fR"
.br
.RI "\fIMutex type that supports single-process locking efficiently.\fR"
.ti -1c
.RI "int \fBremoved_\fR"
.br
.RI "\fIKeeps 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...\fR"
.in -1c
.SS Private Methods

.in +1c
.ti -1c
.RI "void \fBoperator=\fR (const ACE_Thread_Mutex &)"
.br
.ti -1c
.RI "\fBACE_Thread_Mutex\fR (const ACE_Thread_Mutex &)"
.br
.in -1c
.SS Friends

.in +1c
.ti -1c
.RI "class \fBACE_Condition_Thread_Mutex\fR"
.br
.in -1c
.SH DETAILED DESCRIPTION
.PP 
ACE_Thread_Mutex wrapper (only valid for threads in the same process).
.PP
.PP
 This implementation is optimized for locking threads that are in the same process. It maps to <CRITICAL_SECTION>s on NT and  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  when they need a recursive mutex. 
.PP
.SH CONSTRUCTOR & DESTRUCTOR DOCUMENTATION
.PP 
.SS ACE_Thread_Mutex::ACE_Thread_Mutex (const \fBACE_TCHAR\fR * name = 0, ACE_mutexattr_t * attributes = 0)
.PP
Constructor.
.PP
.SS ACE_Thread_Mutex::~ACE_Thread_Mutex (void)
.PP
Implicitly destroy the mutex.
.PP
.SS ACE_Thread_Mutex::ACE_Thread_Mutex (const ACE_Thread_Mutex &)\fC [private]\fR
.PP
.SH MEMBER FUNCTION DOCUMENTATION
.PP 
.SS int ACE_Thread_Mutex::acquire (\fBACE_Time_Value\fR * tv)
.PP
If <tv> == 0 the call  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. 
.SS int ACE_Thread_Mutex::acquire (\fBACE_Time_Value\fR & tv)
.PP
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. 
.SS int ACE_Thread_Mutex::acquire (void)
.PP
Acquire lock ownership (wait on queue if necessary).
.PP
.SS int ACE_Thread_Mutex::acquire_read (void)
.PP
Acquire mutex ownership. This calls  and is only here to make the  interface consistent with the other synchronization APIs. 
.SS int ACE_Thread_Mutex::acquire_write (void)
.PP
Acquire mutex ownership. This calls  and is only here to make the  interface consistent with the other synchronization APIs. 
.SS void ACE_Thread_Mutex::dump (void) const
.PP
Dump the state of an object.
.PP
.SS const ACE_thread_mutex_t & ACE_Thread_Mutex::lock (void) const
.PP
Return the underlying mutex.
.PP
.SS void ACE_Thread_Mutex::operator= (const ACE_Thread_Mutex &)\fC [private]\fR
.PP
.SS int ACE_Thread_Mutex::release (void)
.PP
Release lock and unblock a thread at head of queue.
.PP
.SS int ACE_Thread_Mutex::remove (void)
.PP
Explicitly destroy the mutex. Note that only one thread should call this method since it doesn't protect against race conditions. 
.SS int ACE_Thread_Mutex::tryacquire (void)
.PP
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>. 
.SS int ACE_Thread_Mutex::tryacquire_read (void)
.PP
Conditionally acquire mutex (i.e., won't block). This calls <tryacquire> 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, <errno> is set to <EBUSY>. 
.SS int ACE_Thread_Mutex::tryacquire_write (void)
.PP
Conditionally acquire mutex (i.e., won't block). This calls <tryacquire> 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, <errno> is set to <EBUSY>. 
.SS int ACE_Thread_Mutex::tryacquire_write_upgrade (void)
.PP
This is only here to make the  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. 
.SH FRIENDS AND RELATED FUNCTION DOCUMENTATION
.PP 
.SS class ACE_Condition_Thread_Mutex\fC [friend]\fR
.PP
.SH MEMBER DATA DOCUMENTATION
.PP 
.SS ACE_Thread_Mutex::ACE_ALLOC_HOOK_DECLARE
.PP
Declare the dynamic allocation hooks.
.PP
.SS ACE_thread_mutex_t ACE_Thread_Mutex::lock_
.PP
Mutex type that supports single-process locking efficiently.
.PP
.SS int ACE_Thread_Mutex::removed_
.PP
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...
.PP


.SH AUTHOR
.PP 
Generated automatically by Doxygen for ACE from the source code.