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
135
136
137
138
139
|
//
// ScopedLock.h
//
// Library: Foundation
// Package: Threading
// Module: Mutex
//
// Definition of the ScopedLock template class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_ScopedLock_INCLUDED
#define Foundation_ScopedLock_INCLUDED
#include "Poco/Foundation.h"
namespace Poco {
template <class M>
class ScopedLock
/// A class that simplifies thread synchronization
/// with a mutex.
/// The constructor accepts a Mutex (and optionally
/// a timeout value in milliseconds) and locks it.
/// The destructor unlocks the mutex.
{
public:
explicit ScopedLock(M& mutex): _mutex(mutex)
{
_mutex.lock();
}
ScopedLock(M& mutex, long milliseconds): _mutex(mutex)
{
_mutex.lock(milliseconds);
}
~ScopedLock()
{
try
{
_mutex.unlock();
}
catch (...)
{
poco_unexpected();
}
}
private:
M& _mutex;
ScopedLock();
ScopedLock(const ScopedLock&);
ScopedLock& operator = (const ScopedLock&);
};
template <class M>
class ScopedLockWithUnlock
/// A class that simplifies thread synchronization
/// with a mutex.
/// The constructor accepts a Mutex (and optionally
/// a timeout value in milliseconds) and locks it.
/// The destructor unlocks the mutex.
/// The unlock() member function allows for manual
/// unlocking of the mutex.
{
public:
explicit ScopedLockWithUnlock(M& mutex): _pMutex(&mutex)
{
poco_assert(_pMutex != nullptr);
_pMutex->lock();
_locked = true;
}
ScopedLockWithUnlock(M& mutex, long milliseconds): _pMutex(&mutex)
{
poco_assert(_pMutex != nullptr);
_pMutex->lock(milliseconds);
_locked = true;
}
~ScopedLockWithUnlock()
{
try
{
unlock();
}
catch (...)
{
poco_unexpected();
}
}
void lock()
{
poco_assert(_pMutex != nullptr);
poco_assert(_locked == false);
_pMutex->lock();
_locked = true;
}
void unlock()
{
if (_locked)
{
poco_assert(_pMutex != nullptr);
_pMutex->unlock();
_locked = false;
}
}
private:
M* _pMutex;
bool _locked = false;
ScopedLockWithUnlock();
ScopedLockWithUnlock(const ScopedLockWithUnlock&);
ScopedLockWithUnlock& operator = (const ScopedLockWithUnlock&);
};
} // namespace Poco
#endif // Foundation_ScopedLock_INCLUDED
|
