# module MonitorMixin

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.

### Constants

EXCEPTION_IMMEDIATE
EXCEPTION_NEVER

### Public Class Methods

extend_object(obj) click to toggle source
Calls superclass method

    # File lib/monitor.rb, line 165
    def self.extend_object(obj)
      super(obj)
      obj.__send__(:mon_initialize)
    end

new(*args) click to toggle source

Use `extend MonitorMixin` or `include MonitorMixin` instead of this constructor. Have look at the examples above to understand how to use this module.

Calls superclass method

    # File lib/monitor.rb, line 255
    def initialize(*args)
      super
      mon_initialize
    end

### Public Instance Methods

mon_enter() click to toggle source

Enters exclusive section.

    # File lib/monitor.rb, line 190
    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() click to toggle source

Leaves exclusive section.

    # File lib/monitor.rb, line 202
    def mon_exit
      mon_check_owner
      @mon_count -=1
      if @mon_count == 0
        @mon_owner = nil
        @mon_mutex.unlock
      end
    end

mon_locked?() click to toggle source

Returns true if this monitor is locked by any thread

    # File lib/monitor.rb, line 214
    def mon_locked?
      @mon_mutex.locked?
    end

mon_owned?() click to toggle source

Returns true if this monitor is locked by current thread.

    # File lib/monitor.rb, line 221
    def mon_owned?
      @mon_mutex.locked? && @mon_owner == Thread.current
    end

mon_synchronize() { || ... } click to toggle source

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

    # File lib/monitor.rb, line 230
    def mon_synchronize
      # Prevent interrupt on handling interrupts; for example timeout errors
      # it may break locking state.
      Thread.handle_interrupt(EXCEPTION_NEVER){ mon_enter }
      begin
        yield
      ensure
        Thread.handle_interrupt(EXCEPTION_NEVER){ mon_exit }
      end
    end

Also aliased as: synchronize
mon_try_enter() click to toggle source

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

    # File lib/monitor.rb, line 173
    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

Also aliased as: try_mon_enter
new_cond() click to toggle source

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

    # File lib/monitor.rb, line 246
    def new_cond
      return ConditionVariable.new(self)
    end

synchronize()
Alias for: mon_synchronize
try_mon_enter()

For backward compatibility

Alias for: mon_try_enter

### Private Instance Methods

mon_check_owner() click to toggle source

    # File lib/monitor.rb, line 272
    def mon_check_owner
      if @mon_owner != Thread.current
        raise ThreadError, "current thread not owner"
      end
    end

mon_enter_for_cond(count) click to toggle source

    # File lib/monitor.rb, line 278
    def mon_enter_for_cond(count)
      @mon_owner = Thread.current
      @mon_count = count
    end

mon_exit_for_cond() click to toggle source

    # File lib/monitor.rb, line 283
    def mon_exit_for_cond
      count = @mon_count
      @mon_owner = nil
      @mon_count = 0
      return count
    end

mon_initialize() click to toggle source

Initializes the `MonitorMixin` after being included in a class or when an object has been extended with the `MonitorMixin`

    # File lib/monitor.rb, line 262
    def mon_initialize
      if defined?(@mon_mutex) && @mon_mutex_owner_object_id == object_id
        raise ThreadError, "already initialized"
      end
      @mon_mutex = Thread::Mutex.new
      @mon_mutex_owner_object_id = object_id
      @mon_owner = nil
      @mon_count = 0
    end