HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
IlmThreadMutex.h
Go to the documentation of this file.
1 ///////////////////////////////////////////////////////////////////////////
2 //
3 // Copyright (c) 2005-2012, Industrial Light & Magic, a division of Lucas
4 // Digital Ltd. LLC
5 //
6 // All rights reserved.
7 //
8 // Redistribution and use in source and binary forms, with or without
9 // modification, are permitted provided that the following conditions are
10 // met:
11 // * Redistributions of source code must retain the above copyright
12 // notice, this list of conditions and the following disclaimer.
13 // * Redistributions in binary form must reproduce the above
14 // copyright notice, this list of conditions and the following disclaimer
15 // in the documentation and/or other materials provided with the
16 // distribution.
17 // * Neither the name of Industrial Light & Magic nor the names of
18 // its contributors may be used to endorse or promote products derived
19 // from this software without specific prior written permission.
20 //
21 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 //
33 ///////////////////////////////////////////////////////////////////////////
34 
35 #ifndef INCLUDED_ILM_THREAD_MUTEX_H
36 #define INCLUDED_ILM_THREAD_MUTEX_H
37 
38 //-----------------------------------------------------------------------------
39 //
40 // class Mutex, class Lock
41 //
42 // Class Mutex is a wrapper for a system-dependent mutual exclusion
43 // mechanism. Actual locking and unlocking of a Mutex object must
44 // be performed using an instance of a Lock (defined below).
45 //
46 // Class lock provides safe locking and unlocking of mutexes even in
47 // the presence of C++ exceptions. Constructing a Lock object locks
48 // the mutex; destroying the Lock unlocks the mutex.
49 //
50 // Lock objects are not themselves thread-safe. You should never
51 // share a Lock object among multiple threads.
52 //
53 // Typical usage:
54 //
55 // Mutex mtx; // Create a Mutex object that is visible
56 // //to multiple threads
57 //
58 // ... // create some threads
59 //
60 // // Then, within each thread, construct a critical section like so:
61 //
62 // {
63 // Lock lock (mtx); // Lock constructor locks the mutex
64 // ... // do some computation on shared data
65 // } // leaving the block unlocks the mutex
66 //
67 //-----------------------------------------------------------------------------
68 
69 #include "IlmThreadExport.h"
70 #include "IlmBaseConfig.h"
71 #include "IlmThreadNamespace.h"
72 
73 #if defined _WIN32 || defined _WIN64
74  #ifdef NOMINMAX
75  #undef NOMINMAX
76  #endif
77  #define NOMINMAX
78  #include <windows.h>
79 #elif HAVE_PTHREAD
80  #include <pthread.h>
81 #endif
82 
84 
85 class Lock;
86 
87 
89 {
90  public:
91 
92  Mutex ();
93  virtual ~Mutex ();
94 
95  private:
96 
97  void lock () const;
98  void unlock () const;
99 
100  #if defined _WIN32 || defined _WIN64
101  mutable CRITICAL_SECTION _mutex;
102  #elif HAVE_PTHREAD
103  mutable pthread_mutex_t _mutex;
104  #endif
105 
106  void operator = (const Mutex& M); // not implemented
107  Mutex (const Mutex& M); // not implemented
108 
109  friend class Lock;
110 };
111 
112 
114 {
115  public:
116 
117  Lock (const Mutex& m, bool autoLock = true):
118  _mutex (m),
119  _locked (false)
120  {
121  if (autoLock)
122  {
123  _mutex.lock();
124  _locked = true;
125  }
126  }
127 
128  ~Lock ()
129  {
130  if (_locked)
131  _mutex.unlock();
132  }
133 
134  void acquire ()
135  {
136  _mutex.lock();
137  _locked = true;
138  }
139 
140  void release ()
141  {
142  _mutex.unlock();
143  _locked = false;
144  }
145 
146  bool locked ()
147  {
148  return _locked;
149  }
150 
151  private:
152 
153  const Mutex & _mutex;
154  bool _locked;
155 };
156 
157 
159 
160 #endif // INCLUDED_ILM_THREAD_MUTEX_H
Lock(const Mutex &m, bool autoLock=true)
#define ILMTHREAD_INTERNAL_NAMESPACE_HEADER_ENTER
#define ILMTHREAD_INTERNAL_NAMESPACE_HEADER_EXIT
#define ILMTHREAD_EXPORT
void acquire()
bool locked()
void release()