Class: Mutex

Inherits:
Object show all
Defined in:
thread.c

Overview

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
  }
}

Instance Method Summary collapse

Constructor Details

#new ⇒ Object

Creates a new Mutex




# File 'thread.c'

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

Instance Method Details

#lock ⇒ Mutex

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

Returns:




# File 'thread.c'

VALUE
rb_mutex_lock(VALUE self)
{

if (rb_mutex_trylock(self) == Qfalse) {
rb_mutex_t *mutex;
rb_thread_t *th = GET_THREAD();
GetMutexPtr(self, mutex);

if (mutex->th == GET_THREAD()) {
    rb_raise(rb_eThreadError, "deadlock; recursive locking");
}

#locked? ⇒ Boolean

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

Returns:

  • (Boolean) 



# File 'thread.c'

VALUE
rb_mutex_locked_p(VALUE self)
{
    rb_mutex_t *mutex;
    GetMutexPtr(self, mutex);
    return mutex->th ? Qtrue : Qfalse;
}

#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.

Returns:




# File 'thread.c'

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

    rb_scan_args(argc, argv, "01", &timeout);
    return rb_mutex_sleep(self, timeout);
}

#try_lock ⇒ Boolean

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

Returns:

  • (Boolean) 



# File 'thread.c'

VALUE
rb_mutex_trylock(VALUE self)
{
rb_mutex_t *mutex;
VALUE locked = Qfalse;
GetMutexPtr(self, mutex);

native_mutex_lock(&mutex->lock);
if (mutex->th == 0) {
mutex->th = GET_THREAD();
locked = Qtrue;

mutex_locked(GET_THREAD(), self);
}

#unlock ⇒ Mutex

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

Returns:




# File 'thread.c'

VALUE
rb_mutex_unlock(VALUE self)
{
    const char *err;
    rb_mutex_t *mutex;
    GetMutexPtr(self, mutex);

    err = rb_mutex_unlock_th(mutex, GET_THREAD());
    if (err) rb_raise(rb_eThreadError, "%s", err);

    return self;
}