blob: 095354974ccdfdec9f03003d142a291dffaaeb12 (
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
135
136
137
138
139
140
141
142
143
144
145
146
|
/*
* Copyright (C) 2007-2023 Xagasoft, All rights reserved.
*
* This file is part of the libbu++ library and is released under the
* terms of the license contained in the file LICENSE.
*/
#ifndef BU_EVENT_H
#define BU_EVENT_H
#include <pthread.h>
#include "bu/mutex.h"
#include "bu/condition.h"
namespace Bu
{
/**
* Represents a true/false state that controls thread synchronization. This
* is primarilly intended to control the synchronization state of
* multithreaded services. For example, telling all threads when to exit.
*
* An Event is either set or unset. If the Event is unset then it can be
* waited on for something to happen. As soon as the Event is set all
* waiting threads are released and new requests to wait are ignored until
* the Event is cleared again.
*
* Threads can also be woken up without setting the Event, which may be
* handy in certain circumstances.
*@ingroup Threading
*/
class Event
{
public:
Event() :
bIsSet( false )
{
}
~Event()
{
}
/**
* Wait indefinitely for the Event to trigger. If the event is already
* set, then return immediately. It's important to note that this may
* return at any time, not only when the Event is set, so examining the
* return value is important.
*@returns the set status of the Event.
*/
bool wait()
{
cBlock.lock();
if( bIsSet )
{
cBlock.unlock();
return true;
}
cBlock.wait();
bool bRet = bIsSet;
cBlock.unlock();
return bRet;
}
/**
* Wait for up to nSec seconds and nUSec nanoseconds for the event to
* trigger. If the Event is already set then return immediately.
*@returns the set status of the Event.
*/
bool wait( int nSec, int nUSec )
{
cBlock.lock();
if( bIsSet )
{
cBlock.unlock();
return true;
}
cBlock.wait( nSec, nUSec );
bool bRet = bIsSet;
cBlock.unlock();
return bRet;
}
/**
* Allow one of the waiting threads to unlock without updating the set
* state of the Event.
*/
void unblockOne()
{
cBlock.lock();
cBlock.signal();
cBlock.unlock();
}
/**
* Allow all waiting threads to unlock and proceed without updating the
* set state of the Event.
*/
void unblockAll()
{
cBlock.lock();
cBlock.broadcast();
cBlock.unlock();
}
/**
* Find out if the Event is in the set state or not.
*@returns True if set, false otherwise.
*/
bool isSet()
{
cBlock.lock();
bool bRet = bIsSet;
cBlock.unlock();
return bRet;
}
/**
* Sets the Event's state to true and triggers all waiting threads.
*/
void set()
{
cBlock.lock();
bIsSet = true;
cBlock.broadcast();
cBlock.unlock();
}
/**
* Sets the Event's state to false. This does NOT trigger any waiting
* threads.
*/
void clear()
{
cBlock.lock();
bIsSet = false;
cBlock.unlock();
}
private:
Condition cBlock; /**< The condition for blocking dequeues. */
bool bIsSet;
};
}
#endif
|
