Class: Mutex

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 65
      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 145
      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 97
      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 75
      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 132
      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 83
      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 110
      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]