concurrent_monitor 0.0.1.ci.release

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0fb40509148c10d59f1faf6655bd3bb5caf6bc2afc17dc7a3e63b7bfae6d04d1
+  data.tar.gz: 071b45c7a8e404b2d8fa6c175355ae8066bdc8693cdff951fce12d07dc2865bd
+SHA512:
+  metadata.gz: 9ec7055d648bb1f10c4f74e28fc0b4d7f2ddbdad9df2851b88ee2f5af2c7cc60cf12ddbd2235e3e45eaadbc78b221bc5a693ec76a44f411866e4b96333c6c025
+  data.tar.gz: 10717aee9fa99a78e800e53bf258e0634e4c7ca81d6f399ebdcecd62701348fb4847c77b14ce340a89076f979c0289eee969348bd3cf7a9d07aae210a4a576f0

data/lib/async/monitor.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'async'
+require_relative '../concurrent_monitor'
+
+Fiber.attr_accessor :concurrent_monitor_task
+
+module Async
+  # Implements the ConcurrentMonitor interface using Async::Tasks
+  class Monitor
+    # Common task interface over Async::Task
+    class Task < ConcurrentMonitor::Task
+      def initialize(name = nil, report_on_exception: true, &block)
+        super()
+        Async(annotation: name, finished: report_on_exception ? nil : Async::Condition.new) do |task|
+          @task = task
+          Fiber.current.concurrent_monitor_task = self
+          block.call(self)
+        end
+      end
+
+      def alive? = @task.alive?
+
+      def current? = @task.current?
+
+      def value = @task.wait
+
+      def stop
+        raise Async::Stop if current?
+
+        # defer stop (need to call value before stopped?) and don't stop if we are already stopped
+        # (since this will change the status to :stopped)
+        @task.stop(true) unless @task.finished?
+        self
+      end
+
+      def stopped?
+        @task.stopped?
+      end
+
+      def to_s = @task.to_s
+
+      def inspect = @task.inspect
+    end
+
+    # Functions
+    module Functions
+      # @return Async::Task
+      def async(...)
+        Task.new(...)
+      end
+
+      # Execute a block, wrapped in a Reactor if this fiber is not already in one
+      def sync(name = nil, &)
+        Sync(annotation: name, &)
+      end
+
+      def current_task
+        Fiber.current.concurrent_monitor_task
+      end
+
+      def new_monitor
+        SINGLETON # there is only one
+      end
+
+      # No-op yield.  This is only really a critical section as long as the fiber is not yielded
+      def synchronize
+        yield
+      end
+
+      def task_dump(io = $stderr)
+        io.puts "=== Async Task Dump at #{Time.now} ==="
+        if Async::Task.current?
+          reactor = Async::Task.current.reactor
+          reactor.print_hierarchy($stderr)
+        else
+          io.puts 'No current Async task context'
+        end
+      end
+    end
+
+    # Condition with timeout support
+    class ConditionVariable < Async::Condition
+      include ConcurrentMonitor::ConditionVariable
+
+      def wait(timeout = nil)
+        return super() unless timeout
+
+        # return values match MonitorMixin::ConditionVariable
+        Async::Task.current.with_timeout(timeout) do
+          super()
+        rescue Async::TimeoutError
+          nil
+        end
+      end
+
+      # Note signal is broadcast anyway, so all the waiting fibers are resumed.
+      alias broadcast signal
+    end
+
+    private_constant :ConditionVariable
+
+    include Functions
+    extend Functions
+
+    def new_condition
+      ConditionVariable.new
+    end
+
+    # @!visibility private
+    SINGLETON = new
+  end
+end

data/lib/concurrent_monitor/barrier.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module ConcurrentMonitor
+  # A Barrier/Waiter for joining and/or enumerating a group of tasks
+  #
+  #  * The iterator methods return lazy enumerators so that results can be processed as tasks complete
+  #  * Methods ending in `!` ensure remaining tasks are stopped if enumeration finishes early, e.g. when an exception is
+  #    raised.
+  class Barrier
+    include Enumerable
+
+    # Create a Barrier, yield it to the supplied block then wait for tasks to complete, ensuring
+    # remaining tasks are stopped.
+    #
+    # @return [Object] the result of the block
+    # @example just start and wait for tasks
+    #   Barrier.wait!(monitor) do |barrier|
+    #      jobs.each { |j| barrier.async { j.run } }
+    #   end
+    # @example enumerate results
+    #   Barrier.wait!(monitor) do |barrier|
+    #      jobs.each { |j| barrier.async { j.run } }
+    #      barrier.to_a
+    #   end
+    # @example short circuit enumeration with each!
+    #  Barrier.wait!(monitor) do |barrier|
+    #     jobs.each { |j| barrier.async { j.run } }
+    #     # using the each! enumerator ensures the remaining tasks are stopped after the first two results are found
+    #     barrier.each!.first(2)
+    #  end
+    def self.wait!(monitor:, &)
+      new(monitor:).wait!(&)
+    end
+
+    # @param [Mixin] monitor
+    def initialize(monitor:)
+      @monitor = monitor
+      @queue = monitor.new_queue
+      @tasks = Set.new
+    end
+
+    # Start a task within the barrier
+    # @param [:to_s] name
+    # @param [Boolean] report_on_exception
+    # @return [Task]
+    def async(name = nil, report_on_exception: false, &)
+      synchronize { monitor.async(name, report_on_exception:) { |t| run_task(t, &) }.tap { |t| tasks << t } }
+    end
+
+    # Yield each task as it completes
+    # @return [Enumerator::Lazy] if no block is given?
+    # @return [void]
+    def each_task
+      return enum_for(:each_task).lazy unless block_given?
+
+      while (t = dequeue)
+        yield t
+      end
+    end
+
+    # {#each_task}, ensuring {#stop}
+    # @return [Enumerator::Lazy] if no block is given?
+    # @return [void]
+    def each_task!(&)
+      return enum_for(:each_task!).lazy unless block_given?
+
+      ensure_stop { each_task(&) }
+    end
+
+    # Yield the value of each task as it completes
+    # @return [Enumerator::Lazy] if no block is given
+    # @return [void]
+    def each
+      return enum_for(:each).lazy unless block_given?
+
+      each_task do |t|
+        v = t.value
+        yield v unless t.stopped?
+      end
+    end
+
+    # {#each}, ensuring {#stop}
+    # @return [Enumerator::Lazy] if no block is given
+    # @return [void]
+    def each!
+      return enum_for(:each!).lazy unless block_given?
+
+      ensure_stop { each(&block) }
+    end
+
+    # Optionally yield then wait for tasks
+    # @yield[self]
+    # @return [Object] result of yield if block is given
+    # @return [self] if no block is given
+    def wait
+      (block_given? ? yield(self) : self).tap { each(&:itself) }
+    end
+
+    # {#wait}, ensuring {#stop}
+    def wait!(&) = ensure_stop { wait(&) }
+
+    def stop
+      current, stopping = synchronize { tasks.partition(&:current?) }
+      stopping.each(&:stop)
+      current.first&.stop
+      self
+    end
+
+    def empty?
+      synchronize { tasks.empty? && queue.empty? }
+    end
+
+    def size
+      tasks.size
+    end
+
+    def ready
+      queue.size
+    end
+
+    def synchronize(&) = monitor.synchronize(&)
+    def new_condition = monitor.new_condition
+
+    private
+
+    attr_reader :monitor, :queue, :tasks
+
+    def ensure_stop(method = nil)
+      yield if block_given?
+      send(method) if method
+    ensure
+      stop
+    end
+
+    def run_task(task)
+      yield(task)
+    ensure
+      queue.push(task)
+    end
+
+    def dequeue
+      synchronize do
+        return nil if empty?
+
+        queue.dequeue.tap { |t| tasks.delete(t) if t }
+      end
+    end
+  end
+end

data/lib/concurrent_monitor/condition_variable.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'wait_timeout'
+
+module ConcurrentMonitor
+  # Concurrency primitive for waiting on signals with optional timeout
+  # @abstract
+  # @see ConcurrentMonitor::new_condition
+  module ConditionVariable
+    include ConcurrentMonitor::WaitTimeout
+
+    # @!method wait(timeout = nil)
+    #   Wait for {#broadcast}
+    #   @param [Numeric] timeout in seconds
+    #   @return [void] always true
+    # @note must be called within the {ConcurrentMonitor::Mixin#synchronize} method of this condition's monitor.
+    # @note A condition return from at any time, regardless of broadcast or timeout. See {#wait_until}, #{wait_while}
+
+    # @!method broadcast
+    #   Signal all waiters
+    # @note must be called within the {ConcurrentMonitor::Mixin#synchronize} method of this condition's monitor.
+
+    # @!parse
+    #   alias signal broadcast
+  end
+end

data/lib/concurrent_monitor/future.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module ConcurrentMonitor
+  # A passive future value
+  class Future
+    def initialize(monitor:, condition: monitor.new_condition)
+      @monitor = monitor
+      @condition = condition
+      @completed = false
+      @value = nil
+      @error = nil
+    end
+
+    # Blocks until the future is completed or the timeout expires
+    # @return [Object] The value with which the future was fulfilled
+    # @raise [StandardError] If the future was rejected
+    def value
+      wait
+      raise @error if @error
+
+      @value
+    end
+
+    def wait(timeout = nil, **wait_opts)
+      synchronize { condition.wait_until(timeout, **wait_opts) { @completed } }
+    end
+
+    # Resolve the future with a block
+    def resolve
+      complete! do
+        @value = yield
+      rescue StandardError => e
+        @error = e
+      end
+    end
+
+    # Fulfills this future with the given value
+    # @param value [Object] The value to fulfill this future with
+    # @return [Boolean] true if the future was fulfilled, false if already completed
+    def fulfill(value)
+      complete! { @value = value }
+    end
+
+    # Rejects this future with the given error
+    # @param error [Exception] The error to reject this future with
+    # @return [Boolean] true if the future was rejected, false if already completed
+    def reject(error)
+      error = error.new('rejected') if error.is_a?(Class)
+      complete! { @error = error }
+    end
+
+    # @return [Boolean] true if this future has been completed
+    def completed?
+      synchronize { @completed }
+    end
+
+    # @return [Boolean] true if this future has not yet been completed
+    def pending?
+      !completed?
+    end
+
+    private
+
+    attr_reader :monitor, :condition
+
+    def complete!
+      synchronize do
+        return false if @completed
+
+        yield
+      ensure
+        @completed = true
+        @condition.broadcast
+      end
+    end
+
+    def synchronize(&)
+      monitor.synchronize(&)
+    end
+  end
+end

data/lib/concurrent_monitor/queue.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module ConcurrentMonitor
+  # A simple queue with timeout suitable for use with a Monitor
+  class Queue
+    # @param [ConcurrentMonitor] monitor for this queue
+    def initialize(monitor:)
+      @items = []
+      @monitor = monitor
+      @condition = monitor.new_condition
+    end
+
+    def push(*items)
+      with_items(__method__, *items, signal: true)
+    end
+    alias enqueue push
+
+    def <<(item)
+      with_items(__method__, item, signal: true)
+    end
+
+    def unshift(*items)
+      with_items(__method__, *items, signal: true)
+    end
+
+    def pop(timeout = nil, **wait_opts)
+      when_not_empty(__method__, timeout, **wait_opts)
+    end
+
+    def shift(timeout = nil, **wait_opts)
+      when_not_empty(__method__, timeout, **wait_opts)
+    end
+    alias dequeue shift
+
+    # For inspection, not synchronised
+    def items
+      @items.dup
+    end
+
+    # For inspection not synchronized!
+    def size
+      @items.size
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      @items.respond_to?(method_name, false) || super
+    end
+
+    # Operates on the underlying Array synchronized by this Queue's monitor
+    # @note Accepts a :signal keyword argument to control whether waiters are signaled
+    def method_missing(...)
+      with_items(...)
+    end
+
+    private
+
+    attr_reader :monitor, :condition
+
+    def with_items(method, *, signal: method.end_with?('!'), &)
+      monitor.synchronize { @items.public_send(method, *, &).tap { condition.broadcast if signal } }
+    end
+
+    def when_not_empty(method, timeout = nil, **wait_opts)
+      monitor.synchronize do
+        condition.wait_while(timeout, **wait_opts) { @items.empty? } if @items.empty?
+        @items.public_send(method)
+      end
+    end
+  end
+end

data/lib/concurrent_monitor/semaphore.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module ConcurrentMonitor
+  # Limits the number of concurrently running tasks started with this Semaphore
+  # @example with Barrier, with early exit
+  # Barrier.wait!(monitor) do |barrier
+  #   # Start a task to feed 100 tasks into the barrier 5 at a time
+  #   Semaphore.new(barrier, 5).async_tasks do |semaphore|
+  #     100.times { |i| semaphore.async { start_job(i) } }
+  #   end
+  #   # Wait! here for the all the tasks, including the feeder, to finish.
+  #   #  but if any one of them fails, all currently running tasks AND the feeder will be stopped
+  # end
+  class Semaphore
+    # Create a semaphore, load it up with tasks, and then wait for those tasks to finish
+    def self.wait(monitor:, limit:, &)
+      new(monitor:, limit:).wait(&)
+    end
+
+    # @param [Mixin|Barrier] monitor the monitor for starting async tasks.
+    def initialize(monitor:, limit:)
+      @monitor = monitor
+      @limit = limit
+      @condition = monitor.new_condition
+      @task_count = 0
+    end
+
+    # Run an async task, to feed other tasks - eg into a barrier
+    #
+    # @return [Task] a task executing block (which is expected to call #{async} to feed tasks )
+    # @note this task counts against the semaphore limit
+    def async_tasks(&block)
+      async do |task|
+        block.call(self)
+        task.stop
+      end
+    end
+
+    # Start a task, blocking until the semaphore can be acquired
+    def async(name = nil, report_on_exception: true, &)
+      synchronize do
+        @condition.wait_while { @task_count >= @limit }
+        @task_count += 1
+      end
+
+      monitor.async(name, report_on_exception:) { |t| run_task(t, &) }
+    end
+
+    # Wait until all tasks are finished (without understanding anything about their results)
+    #
+    # If a block is given it is sent to {#async_tasks} before waiting
+    # @return [self]
+    # @see Barrier
+    def wait(timeout = nil, **wait_opts, &block)
+      async_tasks(&block) if block
+      synchronize { @condition.wait_while(timeout, **wait_opts) { @task_count.positive? } }
+      self
+    end
+
+    def synchronize(&)
+      monitor.synchronize(&)
+    end
+
+    attr_reader :task_count, :limit
+
+    private
+
+    attr_reader :monitor, :condition
+
+    def run_task(task, &block)
+      block.call(task)
+    ensure
+      synchronize do
+        @task_count -= 1
+        @condition.signal
+      end
+    end
+  end
+end

data/lib/concurrent_monitor/task.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative 'wait_timeout'
+
+module ConcurrentMonitor
+  # @abstract
+  # Common interface to underlying tasks
+  class Task
+    # @!method value
+    #  Wait for task to complete and return its value
+    #  @return [Object]
+    #  @raise [StandardError]
+
+    # Wait for task to complete
+    # @return [self]
+    def wait
+      value
+      self
+    end
+
+    alias join wait
+
+    # @!method stop
+    #  @return [self] after stopping
+    #  @raise [Exception] if called from the current task
+
+    # @!method stopped?
+    #  @return [Boolean] true if the task has completed via stop.
+
+    # @!method alive?
+    #  @return [Boolean] true if the task has not reached completion (as seen by the calling task)
+
+    # @!method current?
+    #  @return [Boolean] true if this task is the current thread/fiber
+  end
+end

data/lib/concurrent_monitor/timeout_clock.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module ConcurrentMonitor
+  # The timeout clock tracks monotonic time for the completion of an event
+  #
+  # Inspired by Async::Clock
+  class TimeoutClock
+    # A module for creating and waiting with TimeoutClock
+    module Mixin
+      # @return [Numeric] current monotonic time
+      def now
+        ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      end
+
+      # Create and start a new TimeoutClock
+      def timeout(timeout)
+        return NIL_TIMEOUT_CLOCK unless timeout
+        return timeout if timeout.is_a?(TimeoutClock)
+
+        TimeoutClock.new(timeout).tap(&:start!)
+      end
+
+      # Create a TimeoutClock and wait until block is true. See {#wait_until}
+      # @example
+      #   TimeoutClock.wait_until(60) { closed? || (sleep(1) && false)}
+      def wait_until(timeout = nil, delay: nil, exception: nil, &)
+        timeout(timeout).wait_until(exception:, delay:, &)
+      end
+
+      # Create a TimeoutClock and wait while block is true. See {#wait_while}
+      def wait_while(timeout = nil, delay: nil, exception: nil, &)
+        timeout(timeout).wait_while(exception:, delay:, &)
+      end
+    end
+
+    extend Mixin
+
+    # @param [Numeric] duration the duration in seconds before timeout.
+    def initialize(duration)
+      @timeout = duration
+    end
+
+    # Start the timeout
+    def start!
+      @start = TimeoutClock.now if @timeout
+    end
+
+    # @return [Numeric] remaining duration before timeout
+    def remaining
+      return nil unless @timeout
+
+      @timeout - duration
+    end
+
+    # @return [Boolean] true if the timeout has expired
+    # @yield(remaining)
+    #   if block provided and not yet expired
+    # @yieldparam [Numeric] remaining
+    # @yieldreturn [void]
+    def expired?
+      return true if (rem = remaining)&.negative?
+
+      yield rem if block_given?
+      false
+    end
+
+    # @return [Numeric] time in seconds since {#start!}
+    def duration
+      @start ? TimeoutClock.now - @start : 0
+    end
+
+    # Repeatedly call block, passing remaining duration, until it returns truthy or the timeout is expired
+    # @param [Class] exception to raise on timeout
+    # @param [Numeric] delay duration in seconds to sleep between calls to block
+    # @yield[remaining]
+    # @yieldparam [Numeric] remaining the remaining time in the timeout
+    # @yieldreturn [Boolean] something truthy to indicate the wait is over
+    # @return [Object]
+    #   the truthy value of the block, or false if the timeout was expired and no exception class was provided
+    # @raise [StandardError]
+    #    an instance of the exception class if the timeout expires before the block returns a truthy value
+    def wait_until(exception: nil, delay: nil)
+      loop do
+        next unless expired? do |remaining|
+          if (result = yield remaining)
+            return result
+          end
+
+          sleep([delay, self.remaining].min) if delay
+        end
+
+        raise exception, 'timed out' if exception
+
+        return false
+      end
+    end
+
+    # Wait while block is truthy
+    # @param [StandardError] exception
+    # @yield(remaining)
+    # @yieldparam [Numeric] remaining the remaining time in the timeout
+    # @yieldreturn [Boolean] true if waiting should continue
+    # @return [void]
+    # @raise [StandardError]
+    def wait_while(delay: nil, exception: nil)
+      wait_until(exception:, delay:) { |remaining| !yield remaining }
+    end
+  end
+
+  NIL_TIMEOUT_CLOCK = TimeoutClock.new(nil)
+end

data/lib/concurrent_monitor/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# A unified Monitor interface for both Async (fibers) and Threads.
+module ConcurrentMonitor
+  VERSION = '0.0.1'
+end

data/lib/concurrent_monitor/wait_timeout.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'timeout_clock'
+
+module ConcurrentMonitor
+  # Extends anything with a 'wait(timeout=nil)' method with wait_while and wait_until
+  module WaitTimeout
+    # Repeatedly call wait(timeout) until the condition is true or the timeout duration is expired
+    # @param [TimeoutClock|Integer|nil] timeout
+    #   duration in seconds to wait on the condition before timeout or nil to wait forever
+    # @param [Exception|nil] exception an exception to raise on timeout
+    # @return [Object] the truthy return value of the block
+    # @return [nil] if a timeout occurs
+    def wait_until(timeout = nil, exception: nil)
+      TimeoutClock.wait_until(timeout, exception:) { |remaining| yield || (wait(remaining) && false) }
+    end
+
+    # @return [void] - always falsey
+    # @see wait_until
+    def wait_while(*, **)
+      wait_until(*, **) { !yield }
+    end
+  end
+end

data/lib/concurrent_monitor.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require_relative 'concurrent_monitor/timeout_clock'
+require_relative 'concurrent_monitor/task'
+require_relative 'concurrent_monitor/condition_variable'
+require_relative 'concurrent_monitor/queue'
+require_relative 'concurrent_monitor/barrier'
+require_relative 'concurrent_monitor/future'
+require 'forwardable'
+
+# A unified abstraction layer for synchronization and concurrency primitives that works
+# consistently across both Thread and Fiber-based concurrency models.
+# @example Class usage
+#   require 'concurrent_monitor'
+#   class MyConcurrentResource
+#     include ConcurrentMonitor
+#
+#     def initialize(monitor:)
+#       self.monitor = monitor.new_monitor
+#     end
+#   end
+# @example Async (Fiber-based) usage
+#   require 'async/monitor'
+#   resource = MyConcurrentResource.new(monitor: ConcurrentMonitor.async_monitor)
+# @example Threaded usage
+#   require 'thread/monitor'
+#   resource = MyConcurrentResource.new(monitor: ConcurrentMonitor.thread_monitor)
+module ConcurrentMonitor
+  class << self
+    def async_monitor
+      require 'async/monitor'
+      Async::Monitor
+    end
+
+    def thread_monitor
+      require 'thread/monitor'
+      Thread::Monitor
+    end
+  end
+
+  # Include general wait_until, wait_while
+  include TimeoutClock::Mixin
+
+  extend Forwardable
+
+  # @!attribute [rw] monitor
+  #   @return [Async::Monitor,Thread::Monitor] should be set to an instance of Async::Monitor or Thread::Monitor
+  def_delegators :@monitor, :sync, :async, :current_task, :synchronize, :new_condition, :task_dump
+
+  # @!method new_monitor
+  #   @return [Async::Monitor|Thread::Monitor] a new monitor of the same kind as the current one
+
+  # @!method async(name = nil, report_on_exception: true, &block)
+  # Run a task asynchronously
+  # @return [Task]
+
+  # @!method sync(name = nil, &block)
+  # Run a task immediately, starting a reactor if necessary
+  # @return [Object] the result of the block
+
+  # @!method current_task
+  # @return [Task] The current task which can be compared against other tasks
+
+  # @!method task_dump(io=$stderr)
+  # Dumps a list of running tasks, with backtrace, to the supplied IO
+  # @return [void]
+
+  # @!method synchronize(&block)
+  # Execute block as a (potentially re-entrant) critical section within this monitor
+  #
+  # Synchronisation principles:
+  #   1. Critical sections should be kept brief and focused on manipulating shared state.
+  #   2. Only yield control using monitor based primitives such as ConditionVariable / Queue
+  #   2. Always recheck state when resuming after potentially yielding control
+  #
+  # @note Async::Monitor#synchronize does not provide true mutual exclusion. However,
+  #       Code proven to be thread-safe under Thread::Monitor will also be safe for use with Async::Monitor.
+
+  # @!method new_condition
+  # @return [ConditionVariable]
+
+  # Run a task with a timeout
+  # @param [Numeric|TimeoutClock] timeout
+  # @param [Class|StandardError|nil] exception if set the error to raise on timeout
+  # @return [Object] task result, nil if timed out without exception
+  def with_timeout(timeout, exception: nil, condition: new_condition, &block)
+    done = false
+    task = async do |t|
+      block.call(t)
+    ensure
+      synchronize do
+        done = true
+        condition.broadcast
+      end
+    end
+
+    begin
+      synchronize { condition.wait_until(timeout, exception:) { done } }
+    ensure
+      task.stop
+    end
+
+    task.value
+  end
+
+  # @return [Queue] a new queue synchronized on this monitor
+  def new_queue(monitor: self)
+    Queue.new(monitor:)
+  end
+
+  # Creates a new task barrier
+  # @return [Barrier]
+  def new_barrier(monitor: self)
+    Barrier.new(monitor:)
+  end
+
+  # @see Barrier#wait!
+  def with_barrier(monitor: self, &)
+    Barrier.wait!(monitor:, &)
+  end
+
+  def new_future(monitor: self)
+    Future.new(monitor:)
+  end
+
+  # @!attribute [rw] monitor
+  #   @return [Thread::Monitor|Async::Monitor]
+  attr_accessor :monitor
+end

data/lib/thread/monitor.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require 'monitor'
+require_relative '../concurrent_monitor'
+
+class Thread
+  # A concurrent Monitor based for Threads based on MonitorMixin
+  # This is the standalone monitor class.
+  # @see Monitor::Mixin
+  class Monitor
+    # rubocop:disable Lint/InheritException
+
+    # Raised from when a task is stopped
+    class Stop < Exception; end
+
+    # rubocop:enable Lint/InheritException
+
+    # @!visibility private
+    class ConditionVariable < MonitorMixin::ConditionVariable
+      include ConcurrentMonitor::ConditionVariable
+    end
+
+    # @!visibility private
+    # Common task interface over Thread
+    class Task < ConcurrentMonitor::Task
+      def initialize(name = nil, report_on_exception: true, &block)
+        super()
+        @stopped = nil
+        @thread = Thread.new(self, name, report_on_exception, block) do |t, n, e, b|
+          run_thread(t, n, e, &b)
+        rescue Stop
+          @stopped = true
+          nil
+        ensure
+          @stopped ||= false
+        end
+      end
+
+      def alive? = @thread.alive?
+
+      def current? = @thread == Thread.current
+
+      def value
+        return nil if @stopped
+
+        @thread.value
+      rescue Stop
+        @stopped = true
+        nil
+      end
+
+      def stop
+        raise Stop if current?
+
+        @thread.raise(Stop) if @thread.alive?
+        self
+      rescue ThreadError
+        self # race with alive?
+      end
+
+      # must call join or value before @stopped will be true
+      def stopped?
+        !!@stopped
+      end
+
+      def to_s = @thread.to_s
+
+      def inspect = @thread.inspect
+
+      private
+
+      def run_thread(task, name, report_on_exception)
+        Thread.current.tap do |c|
+          c.report_on_exception = report_on_exception
+          c.name = name.to_s if name
+          c.thread_variable_set(:concurrent_monitor_task, task)
+        end
+        yield task
+      end
+    end
+
+    # @!visibility private
+    # Module functions
+    module Functions
+      def new_monitor
+        Monitor.new
+      end
+
+      # @return [Task]
+      def async(...)
+        start_thread_group
+        Task.new(...)
+      end
+
+      # Just invokes the block
+      def sync(_name = nil, &block)
+        start_thread_group
+        block.call
+      end
+
+      def current_task
+        Thread.current.thread_variable_get(:concurrent_monitor_task)
+      end
+
+      def task_dump(io = $stderr)
+        io.puts "=== Thread Dump at #{Time.now} ==="
+        # Get the current thread group
+        group = Thread.current.group
+
+        if group == ThreadGroup::Default
+          io.puts 'Not in a Thread::Monitor group'
+        else
+          io.puts "Total Threads in #{group}: #{group.list.count}"
+          group.list.each do |thread|
+            io.puts "\n#{thread}"
+            io.puts "→ #{thread.backtrace.join("\n  ")}" if thread.backtrace
+          end
+        end
+      end
+
+      private
+
+      def start_thread_group
+        ThreadGroup.new.add(Thread.current) if Thread.current.group == ThreadGroup::Default
+      end
+    end
+
+    def new_condition
+      # We're using the underlying @mon_data variable but giving ourselves
+      # the enhanced condition variable, which just saves one level of wrapping
+      ConditionVariable.new(@mon_data)
+    end
+
+    include MonitorMixin
+
+    include Functions
+    extend Functions
+  end
+end

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: concurrent_monitor
+version: !ruby/object:Gem::Version
+  version: 0.0.1.ci.release
+platform: ruby
+authors:
+- Grant Gardner
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Simple monitor pattern with a common interface using Thread or Async::Task
+email:
+- grant@lastweekend.com.au
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/async/monitor.rb
+- lib/concurrent_monitor.rb
+- lib/concurrent_monitor/barrier.rb
+- lib/concurrent_monitor/condition_variable.rb
+- lib/concurrent_monitor/future.rb
+- lib/concurrent_monitor/queue.rb
+- lib/concurrent_monitor/semaphore.rb
+- lib/concurrent_monitor/task.rb
+- lib/concurrent_monitor/timeout_clock.rb
+- lib/concurrent_monitor/version.rb
+- lib/concurrent_monitor/wait_timeout.rb
+- lib/thread/monitor.rb
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: An abstract concurrent monitor framework
+test_files: []