Why was Waiter deprecated?

[nickpoorman]

Why was the Waiter deprecated in favor of the Barrier? It seems like there's still a use for Waiter.

In the example below you can see that if I don't explicitly wait for the async tasks to start then it's possible some may not start before stop is executed. Seems like a lot of extra boilerplate that needs to be added to each async task to ensure graceful startup / shutdown.

If we still had Waiter, I could say I know there will be 3 tasks and I want to wait for 3 tasks to finish. By specifying the initial number of tasks up front that I know must start / complete before wait unblocks, I know I'm getting everything started up and shutting down. Without the fixed number up front, there's this subtle bug that all the tasks are not created before stop. I guess I could create a wrapper class to do all this but it seems like a primitive that should be part of the async API.

Or am I thinking about this the wrong way?

# frozen_string_literal: true

require 'minitest/autorun'
require 'async'
require 'async/barrier'

class TestAsyncAssumptions < Minitest::Test
  # This is the pattern we follow to ensure the children are stopped before the parent and that async tasks start before starting.
  def test_barrier
    mutex = Mutex.new
    stop_order = []

    Sync do
      started = Async::Queue.new

      parent = Async do
        # Create a barrier for managing children.
        barrier = Async::Barrier.new

        # Add children through the barrier
        barrier.async do |child|
          child.defer_stop do
            started.push(true)
          end

          sleep(60)
        ensure
          mutex.synchronize { stop_order.push('child1') }
        end

        barrier.async do |child|
          child.defer_stop do
            started.push(true)
          end

          sleep(60)
        ensure
          mutex.synchronize { stop_order.push('child2') }
        end

        barrier.async do |child|
          child.defer_stop do
            started.push(true)
          end

          sleep(60)
        ensure
          mutex.synchronize { stop_order.push('child3') }
        end

        barrier.wait # calling stop on parent will raise Async::Stop here.
      ensure
        # Now stop the children before the parent is done.
        barrier.stop
        mutex.synchronize { stop_order.push('parent') }
      end

      # WARNING: Without the following, some of the async tasks may not have started
      # before we call stop!
      #
      # We must yield in order for async to queue all tasks (ugly).
      # sleep(0.1) while barrier.size < 3
      # Wait until all barrier tasks have started.
      3.times do
        started.pop
      end

      parent.stop
      parent.wait # and then we must wait
      mutex.synchronize { stop_order.push('parent_stopped') }

      want_stop_order = %w[child1 child2 child3 parent parent_stopped]
      assert_equal(want_stop_order, stop_order)
    end
  end
end

[ioquatix]

IIUC your use case, you can now do this instead:

results = []
barrier.wait do |task|
  results << task.wait
  
  # Wait for 3 things:
  break if results.size >= 3
end

Async::Barrier#wait now waits in completion order.

[nickpoorman]

Oh sweet! I didn't realize wait would yield the task like that! Thanks!