blob: 4eda3110bd7cbf4074c22dec7d5d7bb836649936 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef mozilla_Monitor_h
#define mozilla_Monitor_h
#include "mozilla/CondVar.h"
#include "mozilla/Mutex.h"
namespace mozilla {
/**
* Monitor provides a *non*-reentrant monitor: *not* a Java-style
* monitor. If your code needs support for reentrancy, use
* ReentrantMonitor instead. (Rarely should reentrancy be needed.)
*
* Instead of directly calling Monitor methods, it's safer and simpler
* to instead use the RAII wrappers MonitorAutoLock and
* MonitorAutoUnlock.
*/
class Monitor
{
public:
explicit Monitor(const char* aName)
: mMutex(aName)
, mCondVar(mMutex, "[Monitor.mCondVar]")
{
}
~Monitor() {}
void Lock() { mMutex.Lock(); }
void Unlock() { mMutex.Unlock(); }
nsresult Wait(PRIntervalTime aInterval = PR_INTERVAL_NO_TIMEOUT)
{
return mCondVar.Wait(aInterval);
}
nsresult Notify() { return mCondVar.Notify(); }
nsresult NotifyAll() { return mCondVar.NotifyAll(); }
void AssertCurrentThreadOwns() const
{
mMutex.AssertCurrentThreadOwns();
}
void AssertNotCurrentThreadOwns() const
{
mMutex.AssertNotCurrentThreadOwns();
}
private:
Monitor();
Monitor(const Monitor&);
Monitor& operator=(const Monitor&);
Mutex mMutex;
CondVar mCondVar;
};
/**
* Lock the monitor for the lexical scope instances of this class are
* bound to (except for MonitorAutoUnlock in nested scopes).
*
* The monitor must be unlocked when instances of this class are
* created.
*/
class MOZ_STACK_CLASS MonitorAutoLock
{
public:
explicit MonitorAutoLock(Monitor& aMonitor)
: mMonitor(&aMonitor)
{
mMonitor->Lock();
}
~MonitorAutoLock()
{
mMonitor->Unlock();
}
nsresult Wait(PRIntervalTime aInterval = PR_INTERVAL_NO_TIMEOUT)
{
return mMonitor->Wait(aInterval);
}
nsresult Notify() { return mMonitor->Notify(); }
nsresult NotifyAll() { return mMonitor->NotifyAll(); }
private:
MonitorAutoLock();
MonitorAutoLock(const MonitorAutoLock&);
MonitorAutoLock& operator=(const MonitorAutoLock&);
static void* operator new(size_t) CPP_THROW_NEW;
Monitor* mMonitor;
};
/**
* Unlock the monitor for the lexical scope instances of this class
* are bound to (except for MonitorAutoLock in nested scopes).
*
* The monitor must be locked by the current thread when instances of
* this class are created.
*/
class MOZ_STACK_CLASS MonitorAutoUnlock
{
public:
explicit MonitorAutoUnlock(Monitor& aMonitor)
: mMonitor(&aMonitor)
{
mMonitor->Unlock();
}
~MonitorAutoUnlock()
{
mMonitor->Lock();
}
private:
MonitorAutoUnlock();
MonitorAutoUnlock(const MonitorAutoUnlock&);
MonitorAutoUnlock& operator=(const MonitorAutoUnlock&);
static void* operator new(size_t) CPP_THROW_NEW;
Monitor* mMonitor;
};
} // namespace mozilla
#endif // mozilla_Monitor_h
|
