Class Mutex
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()

Creates a new Mutex

[Source]

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

Public Instance methods

exclusive_unlock() {|| ...}

If the mutex is locked, unlocks the mutex, wakes one waiting thread, and yields in a critical section.

[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 92
  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 70
  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 127
  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 78
  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 105
  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]

ruby-doc.org is a community service provided by Happy Camper Studios, a Phoenix, Arizona, Ruby application development company.

Documentation content on ruby-doc.org is provided by remarkable members of the Ruby community.

For more information on the Ruby programming language, visit ruby-lang.org.

Want to help improve Ruby's API docs? See Ruby Documentation Guidelines.