Module: MonitorMixin

Included in:
Monitor
Defined in:
lib/monitor.rb

Overview

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

require 'monitor.rb'

buf = []
buf.extend(MonitorMixin)
empty_cond = buf.new_cond

# consumer
Thread.start do
  loop do
    buf.synchronize do
      empty_cond.wait_while { buf.empty? }
      print buf.shift
    end
  end
end

# producer
while line = ARGF.gets
  buf.synchronize do
    buf.push(line)
    empty_cond.signal
  end
end

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

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.

Defined Under Namespace

Classes: ConditionVariable

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.extend_object(obj) ⇒ Object 



160
161
162
163
 
# File 'lib/monitor.rb', line 160

def self.extend_object(obj)
  super(obj)
  obj.__send__(:mon_initialize)
end

Instance Method Details

#mon_enter ⇒ Object

Enters exclusive section.



185
186
187
188
189
190
191
192
 
# File 'lib/monitor.rb', line 185

def mon_enter
  if @mon_owner != Thread.current
    @mon_mutex.lock
    @mon_owner = Thread.current
    @mon_count = 0
  end
  @mon_count += 1
end

#mon_exit ⇒ Object

Leaves exclusive section.



197
198
199
200
201
202
203
204
 
# File 'lib/monitor.rb', line 197

def mon_exit
  mon_check_owner
  @mon_count -=1
  if @mon_count == 0
    @mon_owner = nil
    @mon_mutex.unlock
  end
end

#mon_synchronize ⇒ Object Also known as: synchronize

Enters exclusive section and executes the block. Leaves the exclusive section automatically when the block exits. See example under MonitorMixin.



211
212
213
214
215
216
217
218
 
# File 'lib/monitor.rb', line 211

def mon_synchronize
  mon_enter
  begin
    yield
  ensure
    mon_exit
  end
end

#mon_try_enter ⇒ Object Also known as: try_mon_enter

Attempts to enter exclusive section. Returns false if lock fails.



168
169
170
171
172
173
174
175
176
177
178
 
# File 'lib/monitor.rb', line 168

def mon_try_enter
  if @mon_owner != Thread.current
    unless @mon_mutex.try_lock
      return false
    end
    @mon_owner = Thread.current
    @mon_count = 0
  end
  @mon_count += 1
  return true
end

#new_cond ⇒ Object

Creates a new MonitorMixin::ConditionVariable associated with the receiver.



225
226
227
 
# File 'lib/monitor.rb', line 225

def new_cond
  return ConditionVariable.new(self)
end