Module: MonitorMixin

Module | MonitorMixin
In: | monitor.rb

Adds monitor functionality to an arbitrary object by mixing the module with `include`. For example:

       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?, and the producer thread (main thread) reads a line from ARGF and push it to buf, then call empty_cond.signal.

### Methods

extend_object mon_enter mon_exit mon_synchronize mon_try_enter new new_cond synchronize try_mon_enter

### Classes and Modules

Class MonitorMixin::ConditionVariable

### Public Class methods

extend_object(obj)

[Source]

    # File monitor.rb, line 173
      def self.extend_object(obj)
        super(obj)
        obj.instance_eval {mon_initialize()}
      end

new(*args)

[Source]

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

### Public Instance methods

mon_enter()

Enters exclusive section.

[Source]

    # File monitor.rb, line 200
      def mon_enter
        Thread.critical = true
        mon_acquire(@mon_entering_queue)
        @mon_count += 1
        Thread.critical = false
      end

mon_exit()

Leaves exclusive section.

[Source]

    # File monitor.rb, line 210
      def mon_exit
        mon_check_owner
        Thread.critical = true
        @mon_count -= 1
        if @mon_count == 0
          mon_release
        end
        Thread.critical = false
        Thread.pass
      end

mon_synchronize() {|| ...}

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

[Source]

    # File monitor.rb, line 226
      def mon_synchronize
        mon_enter
        begin
          yield
        ensure
          mon_exit
        end
      end

mon_try_enter()

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

[Source]

    # File monitor.rb, line 181
      def mon_try_enter
        result = false
        Thread.critical = true
        if @mon_owner.nil?
          @mon_owner = Thread.current
        end
        if @mon_owner == Thread.current
          @mon_count += 1
          result = true
        end
        Thread.critical = false
        return result
      end

new_cond()

FIXME: This isn’t documented in Nutshell.

[Source]

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

synchronize()

Alias for mon_synchronize

try_mon_enter()

Alias for mon_try_enter

[Validate]