🔍

No recent searches

# class Thread::Mutex

`Thread::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
      }
    }

### Public Class Methods

Thread::Mutex.new → mutex
Source

    # File thread_sync.rb, line 76
    def initialize
    end

Creates a new `Mutex`

### Public Instance Methods

lock → self
Source

    # File thread_sync.rb, line 100
    def lock
      Primitive.rb_mut_lock
    end

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

locked? → true or false
Source

    # File thread_sync.rb, line 83
    def locked?
      Primitive.cexpr! %q{ RBOOL(mutex_locked_p(mutex_ptr(self))) }
    end

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

owned? → true or false
Source

    # File thread_sync.rb, line 91
    def owned?
      Primitive.rb_mut_owned_p
    end

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

sleep(timeout = nil) → number or nil
Source

    # File thread_sync.rb, line 147
    def sleep(timeout = nil)
      Primitive.rb_mut_sleep(timeout)
    end

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.

synchronize { ... } → result of the block
Source

    # File thread_sync.rb, line 127
    def synchronize
      raise ThreadError, "must be called with a block" unless defined?(yield)

      Primitive.rb_mut_synchronize
    end

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

try_lock → true or false
Source

    # File thread_sync.rb, line 109
    def try_lock
      Primitive.rb_mut_trylock
    end

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

unlock → self
Source

    # File thread_sync.rb, line 118
    def unlock
      Primitive.rb_mut_unlock
    end

Releases the lock. Raises `ThreadError` if `mutex` wasn’t locked by the current thread.