In Files

  • thread.rb

Class/Module Index [+]

Quicksearch

Mutex

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
  }
}

Public Class Methods

new() click to toggle source

Creates a new Mutex

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

Public Instance Methods

exclusive_unlock() click to toggle source

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

 
               # 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() click to toggle source

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

 
               # 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?() click to toggle source

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

 
               # File thread.rb, line 70
def locked?
  @locked
end
            
synchronize() click to toggle source

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

 
               # File thread.rb, line 127
def synchronize
  lock
  begin
    yield
  ensure
    unlock
  end
end
            
try_lock() click to toggle source

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

 
               # 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() click to toggle source

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

 
               # 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
            

Commenting is here to help enhance the documentation. For example, code samples, or clarification of the documentation.

If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.

If you wish to post a correction of the docs, please do so, but also file bug report so that it can be corrected for the next release. Thank you.

If you want to help improve the Ruby documentation, please visit Documenting-ruby.org.

blog comments powered by Disqus