class ConditionVariable

ConditionVariable objects augment class Mutex. Using condition variables, it is possible to suspend while in the middle of a critical section until a resource becomes available.

Example:

require 'thread'
mutex = Mutex.new
resource = ConditionVariable.new
a = Thread.new {
 mutex.synchronize {
 # Thread 'a' now needs the resource
 resource.wait(mutex)
 # 'a' can now have the resource
 }
}
b = Thread.new {
 mutex.synchronize {
 # Thread 'b' has finished using the resource
 resource.signal
 }
}

Public Class Methods

new() click to toggle source

Creates a new condition variable instance.

static VALUE
rb_condvar_initialize(VALUE self)
{
 RSTRUCT_SET(self, CONDVAR_WAITERS, ary_buf_new());
 return self;
}

Public Instance Methods

broadcast() click to toggle source

Wakes up all threads waiting for this lock.

static VALUE
rb_condvar_broadcast(VALUE self)
{
 wakeup_all_threads(GET_CONDVAR_WAITERS(self));
 return self;
}

marshal_dump() click to toggle source

static VALUE
undumpable(VALUE obj)
{
 rb_raise(rb_eTypeError, "can't dump %"PRIsVALUE, rb_obj_class(obj));
 UNREACHABLE;
}

signal() click to toggle source

Wakes up the first thread in line waiting for this lock.

static VALUE
rb_condvar_signal(VALUE self)
{
 wakeup_first_thread(GET_CONDVAR_WAITERS(self));
 return self;
}

wait(mutex, timeout=nil) click to toggle source

Releases the lock held in mutex and waits; reacquires the lock on wakeup.

If timeout is given, this method returns after timeout seconds passed, even if no other thread doesn't signal.

static VALUE
rb_condvar_wait(int argc, VALUE *argv, VALUE self)
{
 VALUE waiters = GET_CONDVAR_WAITERS(self);
 VALUE mutex, timeout;
 struct sleep_call args;
 rb_scan_args(argc, argv, "11", &mutex, &timeout);
 args.mutex = mutex;
 args.timeout = timeout;
 rb_ary_push(waiters, rb_thread_current());
 rb_ensure(do_sleep, (VALUE)&args, delete_current_thread, waiters);
 return self;
}