In concurrent programming, a monitor is an object or module intended to be used safely by more than one thread. The defining characteristic of a monitor is that its methods are executed with mutual exclusion. That is, at each point in time, at most one thread may be executing any of its methods. This mutual exclusion greatly simplifies reasoning about the implementation of monitors compared to reasoning about parallel code that updates a data structure.
You can read more about the general principles on the Wikipedia page for Monitors
Examples
Simple object.extend
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | require 'monitor.rb'buf = []buf.extend(MonitorMixin)empty_cond = buf.new_cond# consumerThread.start do loop do buf.synchronize do empty_cond.wait_while { buf.empty? } print buf.shift end endend# producerwhile line = ARGF.gets buf.synchronize do buf.push(line) empty_cond.signal endend |
The consumer thread waits for the producer thread to push a line to buf
while buf.empty?. The producer thread (main thread) reads a
line from ARGF and pushes it into buf then calls
empty_cond.signal to notify the consumer thread of new data.
Simple Class include
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 | require 'monitor'class SynchronizedArray < Array include MonitorMixin def initialize(*args) super(*args) end alias :old_shift :shift alias :old_unshift :unshift def shift(n=1) self.synchronize do self.old_shift(n) end end def unshift(item) self.synchronize do self.old_unshift(item) end end # other methods ...end |
SynchronizedArray implements an Array with synchronized access
to items. This Class is implemented as subclass of
Array which includes the MonitorMixin
module.