RWTMonitor<Mutex>

Module:  Threads   Package:  Synchronization

Base Class

• Local Index
• Header File
• Description
• Example
• Public Typedef
• Protected Typedefs
• Protected Constructors
• Protected Destructor
• Protected Member Operator
• Protected Member Functions
• See Also

Members

acquire() isAcquired() LockGuard monitor()

mutex() MutexType operator=() release()

RWTMonitor() tryAcquire() TryLockGuard UnlockGuard

~RWTMonitor()

#include <rw/sync/RWTMonitor.h> 

Subclassing from RWTMonitor<Mutex> provides a convenient way to synchronize the member functions used to access the data or resources encapsulated by a class. RWTMonitor<Mutex> supplies the mutual exclusion and guard mechanisms for synchronizing member functions; any functions that must be synchronized use the supplied guard type to lock and unlock the monitor upon entry and exit from the function.

One advantage of using RWTMonitor<Mutex> as a base-class instead of directly inheriting from or including some synchronization class, is the monitor() member function. If you were to use your own mutex member for synchronization, you would have to cast away the const-ness of this in const member functions before acquiring or releasing the mutex. The monitor() function eliminates this inconvenience by always returning a non-const instance of the monitor. The reference returned by monitor() can be used to initialize any of public guard types defined by the RWTMonitor<Mutex> class.

#include <rw/sync/RWTMonitor.h>
#include <rw/sync/RWMutexLock.h>

class MyClass : public RWTMonitor<RWMutexLock> {
   public:
      void myFunc1(void);         // Synchronized Function 
                                  // (Non-atomic)
      void myFunc2(void) const;   // Synchronized Function
                                  // (Atomic)
   private:
      void helper(void) const;    // Assumes lock is already
                                  // acquired!
};
   
void MyClass::myFunc1(void)
{
                           // Use a guard to lock the monitor 
                           // (and automatically unlock it)
   LockGuard lock(monitor()); 

   // Do something useful...
   {
                           // Temporarily unlock the monitor so
                           // we can call another 
                           // synchronized function
      UnlockGuard unlock(monitor());

                           // Call another synchronized function
      myFunc2();

                           // Monitor automatically re-locked 
                           // upon exit from block
   }
                           // Do some more stuff
}

void MyClass::myFunc2(void) const
{
                           // Use a guard to lock the monitor 
                           //(and automatically unlock it)
  LockGuard lock(monitor()); 

  helper();                // Call a private helper function
}

void MyClass::helper(void) const
{
                           // Debug Mode - Make sure the monitor
                           // is acquired by this thread!
   RWTHRASSERT(monitor().isAcquired()); 

                           // Do something useful...
}

typedef Mutex   MutexType;

typedef RWTLockGuard< RWTMonitor< Mutex > >     LockGuard;
typedef RWTUnlockGuard< RWTMonitor< Mutex > >   UnlockGuard;
typedef RWTTryLockGuard< RWTMonitor< Mutex > >  TryLockGuard;

Predefined guards for use with monitors.

RWTMonitor();

Constructs a default instance, initializing the mutex.

RWTMonitor(RWStaticCtor);

Constructs a static instance. This constructor does not initialize the mutex; the mutex will be initialized the first time it is accessed.

RWTMonitor(const RWTMonitor<Mutex>& second);

This copy constructor does not actually copy anything (mutexes generally cannot be copied). It is provided so that you can define a copy constructor in your derived class.

~RWTMonitor();

Destructor.

RWTMonitor<Mutex>&
operator=(const RWTMonitor<Mutex>&);

This assignment operator does not actually assign anything (mutexes generally cannot be assigned). It is provided so that you can define an assignment operator in your derived class.

void
acquire();

Locks the monitor by acquiring the monitor's mutex.

bool
isAcquired() const;

Determines whether the calling thread currently owns the monitor.

---

NOTE -- This function is primarily intended for use in precondition assertions, and is only available when you build the debug version of the module.

---

RWTMonitor<Mutex>&
monitor() const;

Casts away const and returns a reference to self. This allows you to avoid explicitly casting away const on the this pointer in every const member function that needs to lock the monitor.

Mutex&
mutex();

Returns the monitor's mutex.

void
release();

Unlocks the monitor by releasing the monitor's mutex.

bool
tryAcquire():

Conditionally locks the monitor if the monitor can be locked without blocking.

RWMutexLock, RWTLockGuard<Resource>, RWTUnlockGuard<Resource>, RWTTryLockGuard<Resource>

© Copyright Rogue Wave Software, Inc. All Rights Reserved.
Rogue Wave and SourcePro are registered trademarks of Rogue Wave Software, Inc. in the United States and other countries. All other trademarks are the property of their respective owners.
Contact Rogue Wave about documentation or support issues.