# Mutex (Class)

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

[Source]

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

        self.taint
      end

## Public Instance methods

locked?()

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

[Source]

    # File thread.rb, line 71
      def locked?
        @locked
      end

try_lock()

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

[Source]

    # File thread.rb, line 79
      def try_lock
        result = false
        Thread.critical = true
        unless @locked
          @locked = true
          result = true
        end
        Thread.critical = false
        result
      end

lock()

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

[Source]

    # File thread.rb, line 93
      def lock
        while (Thread.critical = true; @locked)
          @waiting.push Thread.current
          Thread.stop
        end
        @locked = true
        Thread.critical = false
        self
      end

unlock()

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

[Source]

    # File thread.rb, line 106
      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

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 128
      def synchronize
        lock
        begin
          yield
        ensure
          unlock
        end
      end

exclusive_unlock() {|| ...}

FIXME: not documented in Pickaxe/Nutshell.

[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

[Validate]