Class: ConditionVariable (Ruby 2.3.4)

    In Files

    • thread_sync.c

    Class/Module Index [+]

    Quicksearch

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