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.waitDefined in:
wait_group.crConstructors
Class Method Summary
- 
        .wait(&) : Nil
        
          Yields a WaitGroupinstance 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
endInstance 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