class Thread::Monitor::ConditionVariable - Documentation for Ruby 4.1
Description: class Thread::Monitor::ConditionVariable: Condition variables, allow to suspend the current thread while in the middle of a critical section until a condition is met, such as a resource being
Keywords: ruby,class,Thread::Monitor::ConditionVariable

🔍

No recent searches

# class Thread::Monitor::ConditionVariable

Condition variables, allow to suspend the current thread while in the middle of a critical section until a condition is met, such as a resource being available.

    Example:

      monitor = Thread::Monitor.new

      resource_available = false
      condvar = monitor.new_cond

      a1 = Thread.new {
        # Thread 'a1' waits for the resource to become available and consumes
        # the resource.
        monitor.synchronize {
          condvar.wait_until { resource_available }
          # After the loop, 'resource_available' is guaranteed to be true.

          resource_available = false
          puts "a1 consumed the resource"
        }
      }

      a2 = Thread.new {
        # Thread 'a2' behaves like 'a1'.
        monitor.synchronize {
          condvar.wait_until { resource_available }
          resource_available = false
          puts "a2 consumed the resource"
        }
      }

      b = Thread.new {
        # Thread 'b' periodically makes the resource available.
        loop {
          monitor.synchronize {
            resource_available = true

            # Notify one waiting thread if any.  It is possible that neither
            # 'a1' nor 'a2 is waiting on 'condvar' at this moment.  That's OK.
            condvar.signal
          }
          sleep 1
        }
      }

      # Eventually both 'a1' and 'a2' will have their resources, albeit in an
      # unspecified order.
      [a1, a2].each {|th| th.join}

### Public Instance Methods

broadcast ()
Source

    # File thread_sync.rb, line 703
    def broadcast
      @monitor.mon_check_owner
      @cond.broadcast
    end

Wakes up all threads waiting for this lock.

signal ()
Source

    # File thread_sync.rb, line 695
    def signal
      @monitor.mon_check_owner
      @cond.signal
    end

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

wait (timeout = nil)
Source

    # File thread_sync.rb, line 669
    def wait(timeout = nil)
      @monitor.mon_check_owner
      @monitor.wait_for_cond(@cond, timeout)
    end

Releases the lock held in the associated monitor 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.

wait_until () { || ... }
Source

    # File thread_sync.rb, line 686
    def wait_until
      until yield
        wait
      end
    end

Calls wait repeatedly until the given block yields a truthy value.

wait_while () { || ... }
Source

    # File thread_sync.rb, line 677
    def wait_while
      while yield
        wait
      end
    end

Calls wait repeatedly while the given block yields a truthy value.