class WaitGroup
Overview
Suspend execution until a collection of fibers are finished.
The wait group is a declarative counter of how many concurrent fibers have
been started. Each such fiber is expected to call #done
to report that they
are finished doing their work. Whenever the counter reaches zero the waiters
will be resumed.
This is a simpler and more efficient alternative to using a Channel(Nil)
then looping a number of times until we received N messages to resume
execution.
Basic example:
require "wait_group"
wg = WaitGroup.new(5)
5.times do
spawn do
do_something
ensure
wg.done # the fiber has finished
end
end
# suspend the current fiber until the 5 fibers are done
wg.wait
Defined in:
wait_group.crConstructors
Class Method Summary
-
.wait(&) : Nil
Yields a
WaitGroup
instance and waits at the end of the block for all of the work enqueued inside it to complete.
Instance Method Summary
-
#add(n : Int32 = 1) : Nil
Increments the counter by how many fibers we want to wait for.
-
#done : Nil
Decrements the counter by one.
-
#spawn(*, name : String | Nil = nil, &block) : Fiber
Increment the counter by 1, perform the work inside the block in a separate fiber, decrementing the counter after it completes or raises.
-
#wait : Nil
Suspends the current fiber until the counter reaches zero, at which point the fiber will be resumed.
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, root : String)from_json(string_or_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
Class Method Detail
Yields a WaitGroup
instance and waits at the end of the block for all of
the work enqueued inside it to complete.
WaitGroup.wait do |wg|
items.each do |item|
wg.spawn { process item }
end
end
Instance Method Detail
Increments the counter by how many fibers we want to wait for.
A negative value decrements the counter. When the counter reaches zero,
all waiting fibers will be resumed.
Raises RuntimeError
if the counter reaches a negative value.
Can be called at any time, allowing concurrent fibers to add more fibers to
wait for, but they must always do so before calling #done
that would
decrement the counter, to make sure that the counter may never inadvertently
reach zero before all fibers are done.
Decrements the counter by one. Must be called by concurrent fibers once they have finished processing. When the counter reaches zero, all waiting fibers will be resumed.
Increment the counter by 1, perform the work inside the block in a separate
fiber, decrementing the counter after it completes or raises. Returns the
Fiber
that was spawned.
wg = WaitGroup.new
wg.spawn { do_something }
wg.wait
Suspends the current fiber until the counter reaches zero, at which point the fiber will be resumed.
Can be called from different fibers.