Mutex (Class)

In: thread.rb
Parent: Object

Mutex implements a simple semaphore that can be used to coordinate access to shared data from multiple concurrent threads.

Example: 

  require 'thread'
  semaphore = Mutex.new

  a = Thread.new {
    semaphore.synchronize {
      # access shared resource
    }
  }

  b = Thread.new {
    semaphore.synchronize {
      # access shared resource
    }
  }

Methods

exclusive_unlock   lock   locked?   new   synchronize   try_lock   unlock  

Public Class methods

new()

[Source]

# File thread.rb, line 61
  def initialize
    @waiting = []
    @locked = false;
    @waiting.taint              # enable tainted comunication

    self.taint
  end

Public Instance methods

exclusive_unlock() {|| ...}

FIXME: not documented in Pickaxe/Nutshell.

[Source]

# File thread.rb, line 140
  def exclusive_unlock
    return unless @locked
    Thread.exclusive do
      @locked = false
      begin
        t = @waiting.shift
        t.wakeup if t
      rescue ThreadError
        retry
      end
      yield
    end
    self
  end
lock()

Attempts to grab the lock and waits if it isn’t available.

[Source]

# File thread.rb, line 93
  def lock
    while (Thread.critical = true; @locked)
      @waiting.push Thread.current
      Thread.stop
    end
    @locked = true
    Thread.critical = false
    self
  end
locked?()

Returns true if this lock is currently held by some thread.

[Source]

# File thread.rb, line 71
  def locked?
    @locked
  end
synchronize() {|| ...}

Obtains a lock, runs the block, and releases the lock when the block completes. See the example under Mutex.

[Source]

# File thread.rb, line 128
  def synchronize
    lock
    begin
      yield
    ensure
      unlock
    end
  end
try_lock()

Attempts to obtain the lock and returns immediately. Returns true if the lock was granted.

[Source]

# File thread.rb, line 79
  def try_lock
    result = false
    Thread.critical = true
    unless @locked
      @locked = true
      result = true
    end
    Thread.critical = false
    result
  end
unlock()

Releases the lock. Returns nil if ref wasn’t locked.

[Source]

# File thread.rb, line 106
  def unlock
    return unless @locked
    Thread.critical = true
    @locked = false
    begin
      t = @waiting.shift
      t.wakeup if t
    rescue ThreadError
      retry
    end
    Thread.critical = false
    begin
      t.run if t
    rescue ThreadError
    end
    self
  end

[Validate]