123456789_123456789_123456789_123456789_123456789_

Class: Thread::Mutex

Relationships & Source Files
Inherits: Object
Defined in: thread_sync.rb

Overview

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

Example:

semaphore = Thread::Mutex.new

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

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

Class Method Summary

Instance Attribute Summary

Instance Method Summary

Constructor Details

.new ⇒ Mutex

Creates a new Mutex

[ GitHub ] 

  


# File 'thread_sync.rb', line 336



def initialize
end


  







Instance Attribute Details



  

    #locked?  ⇒ Boolean  (readonly)  



  

    

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


  



  [ GitHub ]


  

  


# File 'thread_sync.rb', line 343



def locked?
  Primitive.cexpr! %q{ RBOOL(mutex_locked_p(mutex_ptr(self))) }
end


  








  

    #owned?  ⇒ Boolean  (readonly)  



  

    

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


  



  [ GitHub ]


  

  


# File 'thread_sync.rb', line 351



def owned?
  Primitive.rb_mut_owned_p
end


  







Instance Method Details



  

    #lock  ⇒ self   



  

    

Attempts to grab the lock and waits if it isn’t available. Raises ::ThreadError if mutex was locked by the current thread.


  



  [ GitHub ]


  

  


# File 'thread_sync.rb', line 360



def lock
  Primitive.rb_mut_lock
end


  








  

    #sleep(timeout = nil)  ⇒ Numeric?   



  

    

Releases the lock and sleeps timeout seconds if it is given and non-nil or forever.  Raises ::ThreadError if mutex wasn’t locked by the current thread.



When the thread is next woken up, it will attempt to reacquire the lock.



Note that this method can wakeup without explicit Thread#wakeup call. For example, receiving signal and so on.



Returns the slept time in seconds if woken up, or nil if timed out.


  



  [ GitHub ]


  

  


# File 'thread_sync.rb', line 407



def sleep(timeout = nil)
  Primitive.rb_mut_sleep(timeout)
end


  








  

    #synchronize  ⇒ result of the block   



  

    

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


  





  
Raises:





  [ GitHub ]


  

  


# File 'thread_sync.rb', line 387



def synchronize
  raise ThreadError, "must be called with a block" unless defined?(yield)

  Primitive.rb_mut_synchronize
end


  








  

    #try_lock  ⇒ Boolean   



  

    

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


  



  [ GitHub ]


  

  


# File 'thread_sync.rb', line 369



def try_lock
  Primitive.rb_mut_trylock
end


  








  

    #lock  ⇒ self   



  

    

Attempts to grab the lock and waits if it isn’t available. Raises ::ThreadError if mutex was locked by the current thread.


  



  [ GitHub ]


  

  


# File 'thread_sync.rb', line 378



def unlock
  Primitive.rb_mut_unlock
end