# 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

    static VALUE
    mutex_initialize(VALUE self)
    {
        return self;
    }

Creates a new `Mutex`

### Public Instance Methods

lock → self
Source

    VALUE
    rb_mutex_lock(VALUE self)
    {
        return do_mutex_lock(self, 1);
    }

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

    VALUE
    rb_mutex_locked_p(VALUE self)
    {
        rb_mutex_t *mutex = mutex_ptr(self);

        return RBOOL(mutex->fiber);
    }

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

owned? → true or false
Source

    VALUE
    rb_mutex_owned_p(VALUE self)
    {
        rb_fiber_t *fiber = GET_EC()->fiber_ptr;
        rb_mutex_t *mutex = mutex_ptr(self);

        return mutex_owned_p(fiber, mutex);
    }

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

sleep(timeout = nil) → number or nil
Source

    static VALUE
    mutex_sleep(int argc, VALUE *argv, VALUE self)
    {
        VALUE timeout;

        timeout = rb_check_arity(argc, 0, 1) ? argv[0] : Qnil;
        return rb_mutex_sleep(self, timeout);
    }

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

    static VALUE
    rb_mutex_synchronize_m(VALUE self)
    {
        if (!rb_block_given_p()) {
            rb_raise(rb_eThreadError, "must be called with a block");
        }

        return rb_mutex_synchronize(self, rb_yield, Qundef);
    }

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

    VALUE
    rb_mutex_trylock(VALUE self)
    {
        rb_mutex_t *mutex = mutex_ptr(self);

        if (mutex->fiber == 0) {
            RUBY_DEBUG_LOG("%p ok", mutex);

            rb_fiber_t *fiber = GET_EC()->fiber_ptr;
            rb_thread_t *th = GET_THREAD();
            mutex->fiber = fiber;

            mutex_locked(th, self);
            return Qtrue;
        }
        else {
            RUBY_DEBUG_LOG("%p ng", mutex);
            return Qfalse;
        }
    }

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

unlock → self
Source

    VALUE
    rb_mutex_unlock(VALUE self)
    {
        const char *err;
        rb_mutex_t *mutex = mutex_ptr(self);
        rb_thread_t *th = GET_THREAD();

        err = rb_mutex_unlock_th(mutex, th, GET_EC()->fiber_ptr);
        if (err) rb_raise(rb_eThreadError, "%s", err);

        return self;
    }

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