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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
|
=begin
monitor.rb
Author: Shugo Maeda <shugo@netlab.co.jp>
Version: 1.2.1
USAGE:
foo = Foo.new
foo.extend(MonitorMixin)
cond = foo.new_cond
thread1:
foo.synchronize {
...
cond.wait_until { foo.done? }
...
}
thread2:
foo.synchronize {
foo.do_something
cond.signal
}
=end
module MonitorMixin
module Accessible
protected
attr_accessor :mon_owner, :mon_count
attr_reader :mon_entering_queue, :mon_waiting_queue
end
module Initializable
protected
def mon_initialize
@mon_owner = nil
@mon_count = 0
@mon_entering_queue = []
@mon_waiting_queue = []
end
end
class ConditionVariable
class Timeout < Exception; end
include Accessible
def wait(timeout = nil)
if @monitor.mon_owner != Thread.current
raise ThreadError, "current thread not owner"
end
Thread.critical = true
count = @monitor.mon_count
@monitor.mon_count = 0
@monitor.mon_owner = nil
if @monitor.mon_waiting_queue.empty?
t = @monitor.mon_entering_queue.shift
else
t = @monitor.mon_waiting_queue.shift
end
t.wakeup if t
@waiters.push(Thread.current)
if timeout
t = Thread.current
timeout_thread = Thread.start {
sleep(timeout)
t.raise(Timeout.new)
}
end
begin
Thread.stop
rescue Timeout
@waiters.delete(Thread.current)
ensure
if timeout && timeout_thread.alive?
Thread.kill(timeout_thread)
end
end
Thread.critical = true
while @monitor.mon_owner &&
@monitor.mon_owner != Thread.current
@monitor.mon_waiting_queue.push(Thread.current)
Thread.stop
Thread.critical = true
end
@monitor.mon_owner = Thread.current
@monitor.mon_count = count
Thread.critical = false
end
def wait_while
while yield
wait
end
end
def wait_until
until yield
wait
end
end
def signal
if @monitor.mon_owner != Thread.current
raise ThreadError, "current thread not owner"
end
Thread.critical = true
t = @waiters.shift
t.wakeup if t
Thread.critical = false
Thread.pass
end
def broadcast
if @monitor.mon_owner != Thread.current
raise ThreadError, "current thread not owner"
end
Thread.critical = true
for t in @waiters
t.wakeup
end
@waiters.clear
Thread.critical = false
Thread.pass
end
def count_waiters
return @waiters.length
end
private
def initialize(monitor)
@monitor = monitor
@waiters = []
end
end
include Accessible
include Initializable
extend Initializable
def self.extend_object(obj)
super(obj)
obj.mon_initialize
end
def try_mon_enter
result = false
Thread.critical = true
if mon_owner.nil?
self.mon_owner = Thread.current
end
if mon_owner == Thread.current
self.mon_count += 1
result = true
end
Thread.critical = false
return result
end
def mon_enter
Thread.critical = true
while mon_owner != nil && mon_owner != Thread.current
mon_entering_queue.push(Thread.current)
Thread.stop
Thread.critical = true
end
self.mon_owner = Thread.current
self.mon_count += 1
Thread.critical = false
end
def mon_exit
if mon_owner != Thread.current
raise ThreadError, "current thread not owner"
end
Thread.critical = true
self.mon_count -= 1
if mon_count == 0
self.mon_owner = nil
if mon_waiting_queue.empty?
t = mon_entering_queue.shift
else
t = mon_waiting_queue.shift
end
end
t.wakeup if t
Thread.critical = false
Thread.pass
end
def mon_synchronize
mon_enter
begin
yield
ensure
mon_exit
end
end
alias synchronize mon_synchronize
def new_cond
return ConditionVariable.new(self)
end
private
def initialize(*args)
super
mon_initialize
end
end
class Monitor
include MonitorMixin
alias try_enter try_mon_enter
alias enter mon_enter
alias exit mon_exit
alias owner mon_owner
end
# Local variables:
# mode: Ruby
# tab-width: 8
# End:
|
