Type:
Module

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.

new

new(*args) Class Public methods Use extend MonitorMixin or include

2015-04-19 06:23:38
try_mon_enter

try_mon_enter() Instance Public methods For backward compatibility

2015-04-19 07:06:03
extend_object

extend_object(obj) Class Public methods

2015-04-19 06:16:47
mon_synchronize

mon_synchronize() Instance Public methods Enters exclusive section and executes

2015-04-19 06:43:48
mon_try_enter

mon_try_enter() Instance Public methods Attempts to enter exclusive section

2015-04-19 06:45:56
new_cond

new_cond() Instance Public methods Creates a new

2015-04-19 06:53:03
mon_exit

mon_exit() Instance Public methods Leaves exclusive section.

2015-04-19 06:38:08
mon_enter

mon_enter() Instance Public methods Enters exclusive section.

2015-04-19 06:30:57
synchronize

synchronize() Instance Public methods Alias for:

2015-04-19 07:00:10