class Sync::ConditionVariable

Overview

Suspend a fiber until notified.

A ConditionVariable can be associated to any Lockable.

While one Lockable can be associated to multiple ConditionVariable, one ConditionVariable can only be associated to a single Lockable (one-to-many relation).

Condition variables may only be preferred over WaitGroup or Channel(T) for specific scenarios that need to wake a single fiber (signal) or all waiting fibers (broadcast). For example:

Prefer Channel(T) to pass a local resource around over a Mutex and ConditionVariable to protect a global resource, but sometimes you don't need to pass a value and only need to repeatedly signal one or multiple workers, in which case a condition variable might be useful.

Prefer WaitGroup(T) if you need to wait for a task to complete, or for a set of workers to be ready (specific lifetimes), but sometimes you want to repeatedly or sporadically notify one or many workers that may be added or removed concurrently (unbounded lifetimes), in which case a condition variable might be useful.

Defined in:

sync/condition_variable.cr

Constructors

Instance Method Summary

Instance methods inherited from class Reference

==(other : self)
==(other : JSON::Any)
==(other : YAML::Any)
==(other) ==, dup dup, hash(hasher) hash, initialize initialize, inspect(io : IO) : Nil inspect, object_id : UInt64 object_id, pretty_print(pp) : Nil pretty_print, same?(other : Reference) : Bool
same?(other : Nil) same?, to_s(io : IO) : Nil to_s

Constructor methods inherited from class Reference

new new, unsafe_construct(address : Pointer, *args, **opts) : self unsafe_construct

Class methods inherited from class Reference

pre_initialize(address : Pointer) pre_initialize

Instance methods inherited from class Object

! : Bool !, !=(other) !=, !~(other) !~, ==(other) ==, ===(other : JSON::Any)
===(other : YAML::Any)
===(other) ===, =~(other) =~, as(type : Class) as, as?(type : Class) as?, class class, dup dup, hash(hasher)
hash hash, in?(collection : Object) : Bool
in?(*values : Object) : Bool in?, inspect(io : IO) : Nil
inspect : String inspect, is_a?(type : Class) : Bool is_a?, itself itself, nil? : Bool nil?, not_nil!(message)
not_nil! not_nil!, pretty_inspect(width = 79, newline = "\n", indent = 0) : String pretty_inspect, pretty_print(pp : PrettyPrint) : Nil pretty_print, responds_to?(name : Symbol) : Bool responds_to?, tap(&) tap, to_json(io : IO) : Nil
to_json : String to_json, to_pretty_json(indent : String = " ") : String
to_pretty_json(io : IO, indent : String = " ") : Nil to_pretty_json, to_s(io : IO) : Nil
to_s : String to_s, to_yaml(io : IO) : Nil
to_yaml : String to_yaml, try(&) try, unsafe_as(type : T.class) forall T unsafe_as

Class methods inherited from class Object

from_json(string_or_io : String | IO, root : String)
from_json(string_or_io : String | IO) from_json, from_yaml(string_or_io : String | IO) from_yaml

Macros inherited from class Object

class_getter(*names, &block) class_getter, class_getter!(*names) class_getter!, class_getter?(*names, &block) class_getter?, class_property(*names, &block) class_property, class_property!(*names) class_property!, class_property?(*names, &block) class_property?, class_setter(*names) class_setter, def_clone def_clone, def_equals(*fields) def_equals, def_equals_and_hash(*fields) def_equals_and_hash, def_hash(*fields) def_hash, delegate(*methods, to object) delegate, forward_missing_to(delegate) forward_missing_to, getter(*names, &block) getter, getter!(*names) getter!, getter?(*names, &block) getter?, property(*names, &block) property, property!(*names) property!, property?(*names, &block) property?, setter(*names) setter

Constructor Detail

def self.new(lock : Lockable) #

[View source]

Instance Method Detail

def broadcast : Nil #

Wakes up all waiting fibers at once.

You can wake a single waiting fiber with #signal.


[View source]
def signal : Nil #

Wakes up one waiting fiber.

For RWLock and Shared(T) all readers can acquire, thus multiple readers might be woken at once, but only one writer can acquire, thus only one reader will be woken at a time.

You can wake all waiting fibers with #broadcast.


[View source]
def wait : Nil #

Blocks the calling fiber until the condition variable is signaled.

The lock must be held upon calling. Releases lock before waiting, so any other fiber can acquire the lock while the calling fiber is waiting. The lock is re-acquired before returning.

A RWLock and Shared(T) can be held in either read or write mode, the lock will be reacquired in the same mode (read or write) before returning.

The calling fiber will be woken by #signal or #broadcast.


[View source]