Class: Thread::Mutex

Inherits:
Object show all
Defined in:
thread_sync.c,
thread_sync.c

Overview

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

Instance Method Summary collapse

Constructor Details

#Thread::Mutex.new ⇒ Object

Creates a new Mutex



184
185
186
187
188
 
# File 'thread_sync.c', line 184

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

Instance Method Details

#lock ⇒ self

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

Returns:

  • (self) 


431
432
433
434
435
 
# File 'thread_sync.c', line 431

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

#locked? ⇒ Boolean

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

Returns:

  • (Boolean) 


202
203
204
205
206
207
208
 
# File 'thread_sync.c', line 202

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

    return RBOOL(mutex->fiber);
}

#owned? ⇒ Boolean

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

Returns:

  • (Boolean) 


443
444
445
446
447
448
449
450
 
# File 'thread_sync.c', line 443

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

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

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.

Returns:



622
623
624
625
626
627
628
629
 
# File 'thread_sync.c', line 622

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

#synchronize { ... } ⇒ Object

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

Yields:



653
654
655
656
657
658
659
660
661
 
# File 'thread_sync.c', line 653

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

#try_lock ⇒ Boolean

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

Returns:

  • (Boolean) 


251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
 
# File 'thread_sync.c', line 251

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

#unlock ⇒ self

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

Returns:

  • (self) 


504
505
506
507
508
509
510
511
512
513
514
515
 
# File 'thread_sync.c', line 504

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