async_futures 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d1d673d78fe3b8bae70c67b12abf800e58cd79b95a7690c939b3d6d125d4224a
-  data.tar.gz: 4806d60aa3da8d213aa286874dbc8c7a90902832acb22e35ed00060595a8419f
+  metadata.gz: 7b11b0e5466cc8ba37b992612e1ed73048968cc67e0ca7012317c6fcbc0f1045
+  data.tar.gz: bf5081106fd5cf522744e95b1afe45dbd552018b76ab646757c8acf411d009f4
 SHA512:
-  metadata.gz: 9a3ee85e2d1d7a99feaae35124610c1d6265a43b27da902a3e32f683eb32d159a0b4cb7f6441e71de9e04da8827a30504058f9908976273abf11bec038c97fa8
-  data.tar.gz: 11cb824b92cd4dee667e477a0f67b0b8fce864ce5eef5dd3781fc5f345d27cfd0cdedb349c95695ab957506a46027f67bb6b278825f147f5f6a84045ff59e375
+  metadata.gz: 0f0cf51a97b98203674b3ea71db157908537b105a07a370062ee6e01a3970d7bc4f0ce5f1e7c2080fb4d131802f66f1a96b8980d0ab5400d7724d706f9bd643a
+  data.tar.gz: 832da9a52dcb471f1b8adffa21cb4fac0b52de12f6fc33e7a154d9a42d2c7b830d88014cbbdeaac7a71267575dcd74307ac60c76d4e8f01e140f06b1d4e5d6a8

data/README.md

@@ -2,6 +2,7 @@
 
 ## Launch asynchronous tasks
 
+[![Gem Version](https://badge.fury.io/rb/async_futures.svg?icon=si%3Arubygems)](https://badge.fury.io/rb/async_futures)
 [![CI Status](https://github.com/eestrada/async_futures/actions/workflows/main.yml/badge.svg?branch=master)](https://github.com/eestrada/async_futures/actions/workflows/main.yml)
 
 This library is heavily inspired by Python's `concurrent.futures` module.

data/lib/async_futures/counter.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module AsyncFutures
+  # Simple counter.
+  # Useful to wrap with a SynchronizedDelegator.
+  class Counter
+    attr_reader :value
+
+    def initialize(value = 0)
+      @value = value
+    end
+
+    def increment(amount = 1)
+      @value += amount
+    end
+  end
+end

data/lib/async_futures/executor.rb

@@ -1,19 +1,32 @@
 # frozen_string_literal: true
 
+require_relative 'counter'
 require_relative 'error'
 require_relative 'future'
+require_relative 'synchronized_delegator'
 
 require 'timeout'
 
-module AsyncFutures
-  # `Executor` mixin module.
+module AsyncFutures # rubocop:disable Style/Documentation
+  class << self
+    # Set the name for the current worker.
+    def worker_name=(name)
+      Fiber[:async_futures_worker_name] = name.to_s
+    end
+
+    # Get the name for the current worker.
+    def worker_name
+      Fiber[:async_futures_worker_name]
+    end
+  end
+
+  # `Executor` base class.
   # Has a simple implementation
   # that just runs submitted blocks immediately
   # and returns a completed `Future`.
-  # Can be used standalone as a stateless `Executor`
-  # that runs submitted blocks immediately.
   #
-  # Classes using this mixin should override the `submit` method.
+  # Classes inheriting this class
+  # should at least override the `submit` method.
   #
   # `shutdown` should be overridden if there is cleanup to be performed.
   #
@@ -25,16 +38,26 @@ module AsyncFutures
   # The `map` method should *never* be overridden.
   # This is already logically correct
   # and should work with any `Executor` implementation.
-  module Executor
+  class Executor
+    # initialize private variables that all derived classes need.
+    def initialize(worker_name_prefix: nil)
+      @worker_name_prefix = worker_name_prefix
+      @mutex = Thread::Mutex.new
+      @condition = Thread::ConditionVariable.new
+      @tasks = Thread::Queue.new
+      @worker_count = SynchronizedDelegator.new(Counter.new(0))
+    end
+
     # Schedules the block
     # to be executed as `block.call(*args, **kwargs)`
     # and returns a `Future` object representing the execution of the block.
     #
-    # Some Executor implementations may,
+    # Some `Executor` implementations may,
     # under some or all circumstances,
     # run the given block immediately and synchronously
     # and return an already completed `Future` object.
     def submit(...)
+      refute_shutdown
       Future.new.tap { |future| future.complete(...) }
     end
 
@@ -203,22 +226,67 @@ module AsyncFutures
     #
     # This method returns the return value of the block,
     # or `nil` if no block is given.
-    def shutdown(wait: true, cancel_futures: false, &block) # rubocop:disable Lint/UnusedMethodArgument
-      block&.call(self)
-    ensure # rubocop:disable Lint/EmptyEnsure
-      # Cleanup logic goes here.
-      #
-      # The mixin has no state,
-      # so it has nothing to cleanup.
-      #
-      # Also, this is the only implementation that will *not* raise
-      # an exception when new tasks are submitted after shutdown,
-      # precisely because it has no state
-      # to even keep track of whether shutdown has previously been called or not.
+    def shutdown(wait: true, cancel_futures: false) # rubocop:disable Lint/UnusedMethodArgument
+      yield(self) if block_given?
+    ensure
+      at_first_shutdown do
+        # do nothing for base Executor
+        # even on first shutdown.
+      end
     end
 
-    module_function :submit, :submit_concurrent, :support_concurrency?, :map, :shutdown
+    private
+
+    def synchronize
+      @mutex.synchronize do
+        yield
+      ensure
+        @condition.broadcast
+      end
+    end
 
-    public :submit, :submit_concurrent, :support_concurrency?, :map, :shutdown
+    def wait_until
+      @condition.wait(@mutex) until yield
+    end
+
+    # A simple Enumerator that iterates until the @tasks queue is closed and empty.
+    # Because it is a queue, it can block
+    # so it should only be used under circumstances
+    # where the caller is certain the queue will eventually close and drain.
+    #
+    # Also, the Enumerator can't be shared between threads like the queue itself
+    # can be.
+    def tasks_enum(timeout: nil)
+      Enumerator.new do |yielder|
+        while (task = @tasks.pop(timeout: timeout))
+          yielder << task
+        end
+      end
+    end
+
+    # Shutdown the Executor if it hasn't already been shutdown.
+    # Also run the given block,
+    # but only at the first shutdown attempt.
+    def at_first_shutdown
+      synchronize do
+        return if @tasks.closed?
+
+        @tasks.close
+      end
+
+      yield
+    end
+
+    def refute_shutdown
+      raise "#{self.class.name} instance is shutdown" if @tasks.closed?
+    end
+
+    def new_worker_name
+      if @worker_name_prefix
+        "#{@worker_name_prefix}_#{@worker_count.increment}"
+      else
+        "#{self.class.name}_#{object_id}_worker_#{@worker_count.increment}"
+      end
+    end
   end
 end

data/lib/async_futures/fiber_executor.rb

@@ -2,6 +2,7 @@
 
 require_relative 'error'
 require_relative 'executor'
+require_relative 'synchronized_delegator'
 
 require 'set' # rubocop:disable Lint/RedundantRequireStatement
 
@@ -44,9 +45,7 @@ module AsyncFutures
   # back to the `Fiber::Scheduler`
   # and whether the `Fiber::Scheduler` properly implements
   # `Fiber` switching for those operations.
-  class FiberExecutor
-    include Executor
-
+  class FiberExecutor < Executor
     # Create a new `FiberExecutor`.
     #
     # Spawns fibers via `Fiber.schedule`.
@@ -65,16 +64,17 @@ module AsyncFutures
     # so it is safe to use a single `FiberExecutor` instance across multiple threads.
     # However each thread must have its own `Fiber::Scheduler` set
     # in order to successfully call `submit`.
-    def initialize(treat_as_concurrent: false)
+    #
+    # The parameter `worker_name_prefix` can be used
+    # to optionally add a prefix to generated worker names.
+    def initialize(treat_as_concurrent: false, worker_name_prefix: nil)
       raise Error.new('No Fiber.scheduler set') unless Fiber.scheduler
 
-      super()
+      super(worker_name_prefix: worker_name_prefix)
       @treat_as_concurrent = treat_as_concurrent
-      @is_shutdown = false
-      @futures = Set.new
-      @mutex = Thread::Mutex.new
+      @futures = SynchronizedDelegator.new(Set.new)
 
-      at_exit { shutdown(wait: false) }
+      at_exit { shutdown(wait: false, cancel_futures: true) }
     end
 
     # Asynchronously submit a task for execution.
@@ -84,16 +84,19 @@ module AsyncFutures
       raise ArgumentError.new('No block given') unless block
 
       Future.new.tap do |future|
-        @mutex.synchronize do
-          raise 'FiberExecutor instance is shutdown' if @is_shutdown
+        synchronize do
+          refute_shutdown
 
           # Need to set this immediately to ensure DeadlockError is raised appropriately.
           future.thread = Thread.current
-          @futures.add future
-          future.add_done_callback { |f| @mutex.synchronize { @futures.delete f } }
+          future.add_done_callback { |f| @futures.delete(f) }
+          @futures.add(future)
         end
 
-        Fiber.schedule { future.complete(*args, **kwargs, &block) }
+        Fiber.schedule do
+          AsyncFutures.worker_name = new_worker_name
+          future.complete(*args, **kwargs, &block)
+        end
       end
     end
 
@@ -110,30 +113,17 @@ module AsyncFutures
     # Shutdown `FiberExecutor` instance.
     #
     # See `AsyncFutures::Executor.shutdown` for full documentation.
-    def shutdown(wait: true, cancel_futures: false, &block) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
-      block&.call(self)
+    def shutdown(wait: true, cancel_futures: false) # rubocop:disable Metrics/CyclomaticComplexity
+      yield(self) if block_given?
     ensure
-      unless check_and_set_shutdown!
-        futures_dup = @mutex.synchronize { @futures.dup } if wait || cancel_futures
-        futures_dup.reject!(&:cancel) if cancel_futures
+      at_first_shutdown do
+        if wait || cancel_futures
+          futures_dup = @futures.dup.to_set
+          futures_dup.reject!(&:cancel) if cancel_futures
 
-        # This will deadlock outside a FiberScheduler,
-        futures_dup.reject!(&:join) if wait
-        @mutex.synchronize { @futures.replace(@futures & futures_dup) } if wait || cancel_futures
-      end
-    end
-
-    private
-
-    # Returns the current shutdown state,
-    # then sets internal shutdown state to `true`.
-    # This is all done atomically to avoid race conditions.
-    def check_and_set_shutdown!
-      @mutex.synchronize do
-        return true if @is_shutdown
-
-        @is_shutdown = true
-        return false
+          # This will deadlock outside a FiberScheduler,
+          futures_dup.reject!(&:join) if wait
+        end
       end
     end
   end

data/lib/async_futures/future.rb

@@ -216,8 +216,8 @@ module AsyncFutures
     #
     # It will return `true` if the block was run by this call
     # and `false` if it was *not* run by this call.
-    def complete(*args, **kwargs, &block) # rubocop:disable Style/ArgumentsForwarding,Naming/PredicateMethod
-      raise ArgumentError.new('No block given') unless block
+    def complete(*args, **kwargs) # rubocop:disable Style/ArgumentsForwarding,Naming/PredicateMethod
+      raise ArgumentError.new('No block given') unless block_given?
 
       begin
         return false unless set_running_or_notify_cancel(set_context: true)
@@ -227,7 +227,7 @@ module AsyncFutures
       end
 
       begin
-        result = block.call(*args, **kwargs) # rubocop:disable Style/ArgumentsForwarding
+        result = yield(*args, **kwargs) # rubocop:disable Style/ArgumentsForwarding
       rescue Exception => e # rubocop:disable Lint/RescueException
         set_exception(e)
       else
@@ -502,7 +502,7 @@ module AsyncFutures
     # Make all internal states private visibility
     private_constant :PENDING, :RUNNING, :CANCELLED, :CANCELLED_AND_NOTIFIED, :FINISHED
 
-    def private_join(timeout, &block)
+    def private_join(timeout)
       Timeout.timeout(timeout) do
         @mutex.synchronize do
           unless lockless_done?
@@ -511,7 +511,7 @@ module AsyncFutures
           end
 
           @condition.wait(@mutex) until lockless_done?
-          block.call
+          yield
         end
       end
     end

data/lib/async_futures/process_executor.rb

@@ -4,20 +4,50 @@ require_relative 'executor'
 
 require 'etc'
 require 'set' # rubocop:disable Lint/RedundantRequireStatement
+require 'json'
+require 'base64'
+
+# :nocov:
+raise LoadError.new('ProcessExecutor requires `Process.fork`') unless Process.respond_to?(:fork)
+# :nocov:
 
 module AsyncFutures
   # `Executor` implementation based on Process forking
-  # that uses up to `max_workers` to execute calls concurrently.
+  # that uses up to `max_workers` to execute calls in parallel.
+  #
+  # `ProcessExecutor` specific considerations:
+  #
+  # The `ProcessExecutor` class is not required by default
+  # when loading the overall `AsyncFutures` gem.
+  #
+  # ```ruby
+  # # ProcessExecutor *NOT* loaded
+  # require 'async_futures'
   #
-  # `ProcessExecutor` specific submission considerations:
+  # # ProcessExecutor loaded
+  # require 'async_futures/process_executor'
+  # ```
+  #
+  # This is because it depends on the `'base64'` gem.
+  # This gem was bundled in Ruby 3.3 and prior,
+  # but was unbundled in 3.4 and later
+  # (even though it is still the Ruby core team that maintains this gem).
+  # One goal of `AsyncFutures` is to have no hard dependencies
+  # on code outside the standard library.
+  # Because this Executor does have a hard gem dependency,
+  # it is not loaded by default.
+  #
+  # If you want to use this Executor in Ruby 3.4 or later,
+  # you will need to install the `'base64'` gem as well.
   #
   # For `ProcessExecutor` the tasks are never run immediately upon submission.
   # They are placed into a work queue
   # to be picked up later.
   #
-  # Process workers are not reused for work.
+  # Process workers are not reused for work
+  # like Threads and Ractors are.
   # Each task gets a freshly forked process.
-  # This is because marshalling anonymous blocks is not trivial;
+  # This is because marshalling anonymous blocks is not trivial in Ruby;
   # it is simpler to just fork after the block closure has been defined.
   # Use `ThreadExecutor` or `RactorExecutor`
   # for `Executor` implementations that support worker reuse.
@@ -25,43 +55,66 @@ module AsyncFutures
   # Consequently, this executor is only really useful for expensive calculations
   # where the startup time for a process
   # is dwarfed by the time needed for the actual work.
-  # If RactorExecutor is available on your Ruby version
-  # it is almost certainly a better choice than this.
+  # Although modern machines can fork a process thousands of times per second,
+  # this is very, very slow when machines can do billions of operations per second.
+  #
+  # If `RactorExecutor` is available on your Ruby engine/version
+  # it is probably a better choice for parallel work.
   #
   # This does _not_ guarantee
   # that any particular task will be run concurrently
   # with any other particular task;
-  # that is dependent on how many worker threads and tasks there are
+  # that is dependent on how many workers and tasks there are
   # at any given point in time.
-  class ProcessExecutor
-    include Executor
-
+  class ProcessExecutor < Executor # rubocop:disable Metrics/ClassLength
     # Create a new `ProcessExecutor`.
     #
     # Uses a pool of up to `max_workers`
-    # to execute tasks concurrently.
+    # to execute tasks in parallel.
     # If no value is given for `max_workers`
     # it will default to `[32, Etc.nprocessors + 4].min`.
     # Workers are spawned lazily as needed
     # when tasks are added to the work queue.
     #
     # The parameter `worker_name_prefix` can be used
-    # to optionally add a prefix to generated `Thread` names.
+    # to optionally add a prefix to generated worker names.
     #
-    # If the `reap_after` keyword argument is given,
-    # worker threads will be shut down
-    # if they haven't received any work after this amount of seconds.
-    # If it is `nil` or not given,
-    # they will not be reaped until the `ProcessExecutor` instance is `shutdown`.
-    def initialize(max_workers: nil, worker_name_prefix: '', reap_after: nil)
+    # The parameter `daemonize_workers`,
+    # if set to `true`,
+    # causes workers to reparent under the init process
+    # and allow it to reap them.
+    # If set to `false`,
+    # this will cause the Executor instance to use `Process.detach`
+    # on the PID of each spawned worker,
+    # which will create an extra Ruby thread to reap the PID of each worker.
+    # It defaults to `false`.
+    def initialize(
+      max_workers: nil,
+      worker_name_prefix: nil,
+      daemonize_workers: false
+    )
+      super(worker_name_prefix: worker_name_prefix)
+
       @max_workers = (max_workers || [32, Etc.nprocessors + 4].min).to_i
-      @worker_name_prefix = worker_name_prefix.to_s
-      @reap_after = reap_after
-      @mutex = Thread::Mutex.new
-      @tasks = Thread::Queue.new
+      @daemonize_workers = daemonize_workers
+
+      # All private variables after this point
+      # require synchronization to safely interact with.
+      @futures = {}
+
       @pool = Set.new
+      @pids = Set.new
 
-      at_exit { shutdown(wait: false) }
+      @task_feeder = nil
+      @result_feeder = nil
+
+      # The inter-thread communication between these is necessary for shutdown,
+      # so even if nothing is submitted, we still need these to exist for now.
+      maybe_spawn_task_feeder
+      maybe_spawn_result_feeder
+
+      # at_exit { terminate_workers }
+      at_exit { shutdown(wait: false, cancel_futures: true) }
     end
 
     # Asynchronously submit a task for execution.
@@ -69,25 +122,41 @@ module AsyncFutures
     # See `AsyncFutures::Executor.submit` method for full documentation.
     def submit(*args, **kwargs, &block)
       raise ArgumentError.new('No block given') unless block
-      raise 'ProcessExecutor instance is shutdown' if @tasks.closed?
 
       Future.new.tap do |future|
-        @tasks.push([future, block, args, kwargs])
-        maybe_spawn_worker
+        task_ary = [future, block, args, kwargs]
+
+        synchronize { @futures[future.object_id] = future } # rubocop:disable Lint/HashCompareByIdentity
+        @tasks.push(task_ary)
+        maybe_spawn_task_feeder
+        maybe_spawn_result_feeder
+      rescue ClosedQueueError
+        synchronize { @futures.delete(future.object_id) }
+        refute_shutdown
       end
     end
 
-    alias submit_concurrent submit
+    # :nocov:
 
-    public :map
+    # Always returns `true`
+    # for `ProcessExecutor`.
+    def support_concurrency?
+      true
+    end
+
+    def pool_size
+      synchronize { @pool.size }
+    end
+
+    # :nocov:
 
     # Shutdown `ProcessExecutor` instance.
     #
     # See `AsyncFutures::Executor.shutdown` for full documentation.
-    def shutdown(wait: true, cancel_futures: false, &block)
-      block&.call(self)
+    def shutdown(wait: true, cancel_futures: false)
+      yield(self) if block_given?
     ensure
-      unless check_and_set_shutdown!
+      at_first_shutdown do
         if cancel_futures
           while (task = @tasks.pop)
             future = task[0]
@@ -95,61 +164,165 @@ module AsyncFutures
           end
         end
 
-        if wait
-          synchronize { @pool.dup }.each do |thread|
-            thread.join
-            synchronize { @pool.delete(thread) }
-          end
-        end
+        synchronize { wait_until { all_work_complete? } } if wait
       end
     end
 
+    # # Send `SIGTERM` signal
+    # # to all running workers.
+    # #
+    # # First shuts down the executor.
+    # #
+    # # No processes are signalled if `daemonize_workers` is `true`.
+    # def terminate_workers
+    #   shutdown(wait: false, cancel_futures: true)
+    #   signal_workers('SIGTERM')
+    # end
+
+    # # Send `SIGKILL` signal
+    # # to all running workers.
+    # #
+    # # First shuts down the executor.
+    # #
+    # # No processes are signalled if `daemonize_workers` is `true`.
+    # def kill_workers
+    #   shutdown(wait: false, cancel_futures: true)
+    #   signal_workers('SIGKILL')
+    # end
+
     private
 
-    def synchronize(&)
-      @mutex.synchronize(&)
+    # def signal_workers(signal)
+    #   synchronize { @pids.dup }.each do |pid|
+    #     Process.kill(signal, pid)
+    #   rescue Errno::ECHILD, Errno::ESRCH
+    #     # Do nothing
+    #   ensure
+    #     synchronize { @pids.delete(pid) }
+    #   end
+    # end
+
+    # If the Executor is shutdown *AND* all remaining work as been completed.
+    #
+    # Must be called within a `synchronize` block.
+    def all_work_complete?
+      @pool.empty? && @tasks.closed? && @tasks.empty? && @futures.empty?
     end
 
-    # Returns the current shutdown state,
-    # then sets internal shutdown state to `true`.
-    # This is all done atomically to avoid race conditions.
-    def check_and_set_shutdown!
-      synchronize do
-        return true if @tasks.closed?
+    # The smallest positive float value,
+    # and thus the smallest possible timeout value.
+    SMALLEST_TIMEOUT = 0.0.next_float
 
-        @tasks.close
-        return false
-      end
-    end
+    private_constant :SMALLEST_TIMEOUT
 
-    # Only spawn a worker if one is needed.
-    def maybe_spawn_worker
-      # synchronize when interacting directly with @pool
-      spawn_worker if !@tasks.empty? && synchronize { @pool.size } < @max_workers
+    def maybe_spawn_task_feeder
+      synchronize { spawn_task_feeder unless @task_feeder }
     end
 
-    # Always spawn a worker
-    def spawn_worker # rubocop:disable Metrics/AbcSize
-      thread = Thread.new do
-        Thread.current.name = "#{@worker_name_prefix}_#{Thread.current.object_id}" unless @worker_name_prefix.empty?
+    def spawn_task_feeder # rubocop:disable Metrics/AbcSize
+      @task_feeder = Thread.new("task_feeder_#{object_id}") do |feeder_name|
+        Thread.current.name = feeder_name
+
+        while (task = @tasks.pop)
+          future, block, args, kwargs = task
 
-        while (task = @tasks.pop(timeout: @reap_after))
-          tfuture, tblock, targs, tkwargs = task
+          unless future.set_running_or_notify_cancel
+            synchronize { @futures.delete(future.object_id) }
+            next
+          end
 
-          next unless tfuture.set_running_or_notify_cancel
+          future_object_id = future.object_id
 
-          begin
-            result = tblock.call(*targs, **tkwargs)
+          read_pipe, write_pipe, worker_name = synchronize do
+            wait_until { @pool.size < @max_workers }
+
+            read_pipe, write_pipe = IO.pipe
+            @pool.add(read_pipe)
+            [read_pipe, write_pipe, new_worker_name]
+          end
+
+          pid = Process.fork do
+            # :nocov:
+            Process.daemon(true, true) if @daemonize_workers
+            # :nocov:
+
+            read_pipe.close
+            AsyncFutures.worker_name = worker_name
+            result = block.call(*args, **kwargs)
+            marshalled_result = Marshal.dump(result)
+            b64_enc = Base64.strict_encode64(marshalled_result)
+            json_result = JSON.dump([future_object_id, :result, b64_enc])
           rescue Exception => e # rubocop:disable Lint/RescueException
-            tfuture.set_exception(e)
+            marshalled_exc = Marshal.dump(e)
+            b64_enc = Base64.strict_encode64(marshalled_exc)
+            json_exc = JSON.dump([future_object_id, :exception, b64_enc])
+            write_pipe.write(json_exc)
           else
-            tfuture.set_result(result)
+            write_pipe.write(json_result)
+          ensure
+            write_pipe.close
           end
+          write_pipe.close
+
+          next if @daemonize_workers
+
+          synchronize { @pids.add(pid) }
+          Process.detach(pid)
         end
       ensure
-        synchronize { @pool.delete Thread.current }
+        synchronize do
+          @task_feeder = nil
+        end
       end
-      synchronize { @pool.add thread }
     end
+
+    def maybe_spawn_result_feeder
+      synchronize { spawn_result_feeder unless @result_feeder }
+    end
+
+    def spawn_result_feeder # rubocop:disable Metrics/AbcSize
+      @result_feeder = Thread.new("result_feeder_#{object_id}") do |feeder_name|
+        Thread.current.name = feeder_name
+
+        loop do
+          break_loop, results_pipes = synchronize do
+            wait_until { all_work_complete? || !@pool.empty? }
+
+            [all_work_complete?, @pool.dup]
+          end
+
+          break if break_loop
+
+          next_pipe = results_pipes.lazy.filter { |p| p.wait_readable(SMALLEST_TIMEOUT) }.first
+
+          next if next_pipe.nil?
+
+          synchronize { @pool.delete(next_pipe) }
+
+          msg_raw = begin
+            next_pipe.read
+          ensure
+            next_pipe.close
+          end
+
+          msg = JSON.parse(msg_raw)
+          future_id, type, value = msg
+          b64_dec = Base64.strict_decode64(value)
+          unmarshalled_value = Marshal.load(b64_dec) # rubocop:disable Security/MarshalLoad
+          future = synchronize { @futures.delete(future_id) { raise "future_id not found #{future_id}" } }
+
+          future.set_exception(unmarshalled_value) if type.to_sym.equal? :exception
+          future.set_result(unmarshalled_value) if type.to_sym.equal? :result
+        end
+      ensure
+        synchronize do
+          @result_feeder = nil
+        end
+      end
+    end
+
+    # def log_debug(&)
+    #   AsyncFutures.logger&.debug(&)
+    # end
   end
 end

data/lib/async_futures/ractor_executor.rb

@@ -28,9 +28,7 @@ module AsyncFutures
   # with any other particular task;
   # that is dependent on how many worker threads and tasks there are
   # at any given point in time.
-  class RactorExecutor # rubocop:disable Metrics/ClassLength
-    include Executor
-
+  class RactorExecutor < Executor # rubocop:disable Metrics/ClassLength
     # Create a new `RactorExecutor`.
     #
     # Uses a pool of up to `max_workers`
@@ -41,7 +39,7 @@ module AsyncFutures
     # when tasks are added to the work queue.
     #
     # The parameter `worker_name_prefix` can be used
-    # to optionally add a prefix to generated `Thread` names.
+    # to optionally add a prefix to generated worker names.
     #
     # If the `move_result` keyword argument is `true`,
     # results from worker ractors will be moved instead of copied.
@@ -71,12 +69,13 @@ module AsyncFutures
       make_args_shareable: false,
       copy_args: false
     )
+      super(worker_name_prefix: worker_name_prefix)
+
       if copy_args && !make_args_shareable
         raise ArgumentError.new('`copy_args` cannot be true unless `make_args_shareable` is also true')
       end
 
       @max_workers = (max_workers || [32, Etc.nprocessors + 4].min).to_i
-      @worker_name_prefix = worker_name_prefix
 
       # This value is passed into worker Ractors.
       # If the caller passed something not shareable,
@@ -89,9 +88,6 @@ module AsyncFutures
       @move_args = move_args
       @make_args_shareable = make_args_shareable
       @copy_args = copy_args
-      @mutex = Thread::Mutex.new
-      @condition = Thread::ConditionVariable.new
-      @tasks = Thread::Queue.new
       @worker_tasks_ports = Thread::Queue.new
 
       # All private variables after this point
@@ -101,7 +97,6 @@ module AsyncFutures
       @futures = {}
 
       @pool = Set.new
-      @worker_count = 0
 
       @task_feeder = nil
       @result_feeder = nil
@@ -111,7 +106,7 @@ module AsyncFutures
       maybe_spawn_task_feeder
       maybe_spawn_result_feeder
 
-      at_exit { shutdown(wait: false) }
+      at_exit { shutdown(wait: false, cancel_futures: true) }
     end
 
     # Asynchronously submit a task for execution.
@@ -137,7 +132,7 @@ module AsyncFutures
         maybe_spawn_task_feeder
         maybe_spawn_result_feeder
       rescue ClosedQueueError
-        raise 'RactorExecutor instance is shutdown'
+        refute_shutdown
       end
     end
 
@@ -154,10 +149,10 @@ module AsyncFutures
     # Shutdown `RactorExecutor` instance.
     #
     # See `AsyncFutures::Executor.shutdown` for full documentation.
-    def shutdown(wait: true, cancel_futures: false, &block)
-      block&.call(self)
+    def shutdown(wait: true, cancel_futures: false)
+      yield(self) if block_given?
     ensure
-      unless check_and_set_shutdown!
+      at_first_shutdown do
         if cancel_futures
           while (task = @tasks.pop)
             future = task[0]
@@ -171,38 +166,6 @@ module AsyncFutures
 
     private
 
-    def synchronize(&block)
-      @mutex.synchronize do
-        block.call
-      ensure
-        @condition.broadcast
-      end
-    end
-
-    def wait_until
-      @condition.wait(@mutex) until yield
-    end
-
-    # Returns the current shutdown state,
-    # then sets internal shutdown state to `true`.
-    # This is all done atomically to avoid race conditions.
-    def check_and_set_shutdown!
-      synchronize do
-        return true if @tasks.closed?
-
-        @tasks.close
-        return false
-      end
-    end
-
-    def new_worker_name
-      if @worker_name_prefix
-        "#{@worker_name_prefix}_#{@worker_count += 1}"
-      else
-        "#{self.class.name}_#{object_id}_worker_#{@worker_count += 1}"
-      end
-    end
-
     def maybe_spawn_task_feeder
       synchronize { spawn_task_feeder unless @task_feeder }
     end
@@ -255,9 +218,9 @@ module AsyncFutures
 
         loop do
           break_loop, results_ports_keys = synchronize do
-            wait_until { !@results_ports.empty? || (@pool.empty? && @tasks.closed? && @tasks.empty?) }
+            wait_until { !@results_ports.empty? || (@tasks.closed? && @tasks.empty? && @pool.empty?) }
 
-            [@results_ports.empty? && @pool.empty? && @tasks.closed? && @tasks.empty?, @results_ports.keys]
+            [@tasks.closed? && @tasks.empty? && @pool.empty? && @results_ports.empty?, @results_ports.keys]
           end
 
           break if break_loop
@@ -309,8 +272,9 @@ module AsyncFutures
       worker = Ractor.new(
         new_results_port,
         @move_result,
-        name: new_worker_name
-      ) do |results_port, move_result|
+        new_worker_name
+      ) do |results_port, move_result, worker_name|
+        AsyncFutures.worker_name = worker_name
         tasks_port = Ractor::Port.new
 
         results_port.send(tasks_port)

data/lib/async_futures/synchronized_delegator.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+module AsyncFutures
+  # A Delegator that synchronizes all calls for a delegated object.
+  #
+  # This does not guarantee concurrency safety under all circumstances,
+  # but it does make it easier to be safe.
+  # For example,
+  # any method that returns `self` is potentially unsafe if chained afterward
+  # (because the chained operations can happen outside the synchronized mutex,
+  # and thus are not safe for concurrency).
+  #
+  # The only argument to `new` is  the object to be wrapped.
+  # For concurrency safety, it should no longer be directly accessed
+  # outside the delegator
+  # unless you are know you are in a situation
+  # where the object will not be accessed concurrently.
+  class SynchronizedDelegator < SimpleDelegator
+    def initialize(obj)
+      @mutex = Thread::Mutex.new
+      super
+    end
+
+    # Like regular `method_missing`, but all calls are synchronized.
+    def method_missing(name, *args, **kwargs, &)
+      @mutex.synchronize do
+        # SimpleDelegator#method_missing forwards to __getobj__
+        super
+      end
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      # keep respond_to? consistent
+      super
+    end
+
+    # A synchronized implementation of `clone`.
+    #
+    # Uses a custom implementation of `initialize_clone`
+    # that creates and assigns a new mutex
+    # to the clone.
+    # The internal mutex will also be properly frozen
+    # if the original delegator is frozen.
+    def clone(freeze: nil)
+      @mutex.synchronize do
+        super
+      end
+    end
+
+    # A synchronized implementation of `dup`.
+    #
+    # Uses a custom implementation of `initialize_dup`
+    # that creates and assigns a new mutex
+    # to the duplicate.
+    def dup
+      @mutex.synchronize do
+        super
+      end
+    end
+
+    # A synchronized implementation of `freeze`.
+    #
+    # Also freezes private mutex.
+    def freeze
+      @mutex.synchronize do
+        @mutex.freeze
+        super
+      end
+    end
+
+    private
+
+    def initialize_dup(other) # :nodoc:
+      @mutex = other.instance_variable_get(:@mutex).dup
+      super
+    end
+
+    def initialize_clone(other, freeze: nil) # :nodoc:
+      @mutex = other.instance_variable_get(:@mutex).clone(freeze: freeze)
+      super
+    end
+  end
+end

data/lib/async_futures/thread_executor.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'executor'
+require_relative 'synchronized_delegator'
 
 require 'etc'
 require 'set' # rubocop:disable Lint/RedundantRequireStatement
@@ -22,9 +23,7 @@ module AsyncFutures
   # that is dependent on how many worker threads and tasks there are
   # at any given point in time
   # and whether the `strict_concurrency` argument is passed.
-  class ThreadExecutor # rubocop:disable Metrics/ClassLength
-    include Executor
-
+  class ThreadExecutor < Executor
     # Create a new `ThreadExecutor`.
     #
     # Uses a pool of up to `max_workers`
@@ -102,26 +101,24 @@ module AsyncFutures
     # they will not be reaped until the `ThreadExecutor` instance is `shutdown`.
     #
     # The parameter `worker_name_prefix` can be used
-    # to optionally add a prefix to generated `Thread` worker names.
+    # to optionally add a prefix to generated worker names.
     def initialize(
       max_workers: nil,
       strict_concurrency: false,
       reap_after: nil,
       worker_name_prefix: nil
     )
+      super(worker_name_prefix: worker_name_prefix)
+
       @max_workers = (max_workers || [32, Etc.nprocessors + 4].min).to_i
       @strict_concurrency = strict_concurrency
       @reap_after = reap_after
-      @worker_name_prefix = worker_name_prefix
-      @mutex = Thread::Mutex.new
-      @tasks = Thread::Queue.new
 
       # Set Hash value to `true` when a worker is running
       # and `false` otherwise.
-      @pool = {}
-      @worker_count = 0
+      @pool = SynchronizedDelegator.new({})
 
-      at_exit { shutdown(wait: false) }
+      at_exit { shutdown(wait: false, cancel_futures: true) }
     end
 
     # Asynchronously submit a task for execution.
@@ -136,8 +133,6 @@ module AsyncFutures
 
       Future.new.tap do |f|
         f.complete(*args, **kwargs, &block) unless queue_task(f, *args, **kwargs, &block)
-      rescue ClosedQueueError
-        raise 'ThreadExecutor instance is shutdown'
       end
     end
 
@@ -154,14 +149,12 @@ module AsyncFutures
 
       Future.new.tap do |f|
         raise NoConcurrencyError.new('Tasks exceed potential workers') unless queue_task(f, *args, **kwargs, &block)
-      rescue ClosedQueueError
-        raise 'ThreadExecutor instance is shutdown'
       end
     end
 
     # Return the current size of the worker pool
     def pool_size
-      synchronize { @pool.size }
+      @pool.size
     end
 
     # :nocov:
@@ -177,44 +170,18 @@ module AsyncFutures
     # Shutdown `ThreadExecutor` instance.
     #
     # See `AsyncFutures::Executor.shutdown` for full documentation.
-    def shutdown(wait: true, cancel_futures: false, &block)
-      block&.call(self)
+    def shutdown(wait: true, cancel_futures: false)
+      yield(self) if block_given?
     ensure
-      unless check_and_set_shutdown!
-        if cancel_futures
-          while (task = @tasks.pop)
-            future = task[0]
-            future.cancel
-          end
-        end
+      at_first_shutdown do
+        tasks_enum.lazy.map(&:first).each(&:cancel) if cancel_futures
 
-        if wait
-          synchronize { @pool.dup }.each do |thread|
-            thread.join
-            synchronize { @pool.delete(thread) }
-          end
-        end
+        @pool.dup.to_h.each_key(&:join) if wait
       end
     end
 
     private
 
-    def synchronize(&)
-      @mutex.synchronize(&)
-    end
-
-    # Returns the current shutdown state,
-    # then sets internal shutdown state to `true`.
-    # This is all done atomically to avoid race conditions.
-    def check_and_set_shutdown!
-      synchronize do
-        return true if @tasks.closed?
-
-        @tasks.close
-        return false
-      end
-    end
-
     # Attempt to queue task.
     # Return `true` if successful, `false` otherwise.
     #
@@ -228,59 +195,48 @@ module AsyncFutures
     # based on whether there are any potentially available workers.
     #
     # May spawn a new worker, if the task was queued.
-    def queue_task(future, *args, **kwargs, &block)
+    def queue_task(future, *args, **kwargs, &block) # rubocop:disable Metrics/PerceivedComplexity
       queued = if @strict_concurrency
-                 synchronize do
-                   potential_workers = (@max_workers - @pool.size) + @pool.values.count(&:!)
-                   if (@tasks.size + 1) <= potential_workers
-                     @tasks.push([future, block, args, kwargs])
-                     true
-                   else
-                     raise ClosedQueueError if @tasks.closed?
-
-                     false
-                   end
+                 potential_workers = (@max_workers - @pool.size) + @pool.values.count(&:!)
+                 if (@tasks.size + 1) <= potential_workers
+                   @tasks.push([future, block, args, kwargs])
+                   true
+                 else
+                   raise ClosedQueueError if @tasks.closed?
+
+                   false
                  end
                else
                  @tasks.push([future, block, args, kwargs])
                  true
                end
-
+    rescue ClosedQueueError
+      refute_shutdown
+    else
       queued.tap { maybe_spawn_worker if queued }
     end
 
     # Only spawn a worker if one is needed.
     def maybe_spawn_worker
-      # synchronize when interacting directly with @pool
-      spawn_worker if !@tasks.empty? && synchronize { @pool.size } < @max_workers
-    end
-
-    def new_worker_name
-      synchronize do
-        if @worker_name_prefix
-          "#{@worker_name_prefix}_#{@worker_count += 1}"
-        else
-          "#{self.class.name}_#{object_id}_worker_#{@worker_count += 1}"
-        end
-      end
+      spawn_worker if !@tasks.empty? && @pool.size < @max_workers
     end
 
     # Always spawn a worker
-    def spawn_worker # rubocop:disable Metrics/AbcSize
-      thread = Thread.new do
-        Thread.current.name = new_worker_name
+    def spawn_worker
+      thread = Thread.new(new_worker_name) do |worker_name|
+        AsyncFutures.worker_name = worker_name
         while (task = @tasks.pop(timeout: @reap_after))
-          synchronize { @pool[Thread.current] = true }
+          @pool[Thread.current] = true
 
           tfuture, tblock, targs, tkwargs = task
           tfuture.complete(*targs, **tkwargs, &tblock)
 
-          synchronize { @pool[Thread.current] = false }
+          @pool[Thread.current] = false
         end
       ensure
-        synchronize { @pool.delete Thread.current }
+        @pool.delete(Thread.current)
       end
-      synchronize { @pool[thread] ||= false }
+      @pool[thread] ||= false
     end
   end
 end

data/lib/async_futures/version.rb

@@ -2,5 +2,5 @@
 
 module AsyncFutures
   # Version of the library as a String instance.
-  VERSION = '0.1.2'
+  VERSION = '0.2.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: async_futures
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Ethan Estrada
@@ -21,6 +21,7 @@ files:
 - README.md
 - Rakefile
 - lib/async_futures.rb
+- lib/async_futures/counter.rb
 - lib/async_futures/error.rb
 - lib/async_futures/executor.rb
 - lib/async_futures/fiber_executor.rb
@@ -29,6 +30,7 @@ files:
 - lib/async_futures/logger.rb
 - lib/async_futures/process_executor.rb
 - lib/async_futures/ractor_executor.rb
+- lib/async_futures/synchronized_delegator.rb
 - lib/async_futures/thread_executor.rb
 - lib/async_futures/version.rb
 - sig/async_futures.rbs