Overview

• module Async
  • class Barrier
    • public

    A general purpose synchronisation primitive, which allows one task to wait for a number of other tasks to complete. It can be used in conjunction with class Async::Semaphore.

    • class TaskNode
  • class Clock
    • public

    A convenient wrapper around the internal monotonic clock.
  • class Condition
    • public

    A synchronization primitive, which allows fibers to wait until a particular condition is (edge) triggered.
  • module Console

    Shims for the console gem, redirecting warnings and above to Kernel#warn.
  • class Deadline
    • public

    Represents a deadline timeout with decrementing remaining time.

    • module Zero

      Singleton module for immediate timeouts (zero or negative).
  • class Idler

    A load balancing mechanism that can be used process work when the system is idle.
  • class LimitedQueue
    • public

    A thread-safe queue which limits the number of items that can be enqueued.
  • class List

    A general doublely linked list. This is used internally by class Async::Barrier and class Async::Condition to manage child tasks.

    • class Node

      A linked list Node.
    • class Iterator
  • class Children

    A list of children tasks.
  • class Node

    A node in a tree, used for implementing the task hierarchy.
  • class Notification
    • public

    A synchronization primitive, which allows fibers to wait until a notification is received. Does not block the task which signals the notification. Waiting tasks are resumed on next iteration of the reactor.
  • class PriorityQueue
    • public

    A queue which allows items to be processed in priority order of consumers.
  • class Promise
    • public

    A promise represents a value that will be available in the future.

    • class Cancel

      Exception used to indicate cancellation.
  • class Queue
    • asynchronous
    • public

    A thread-safe queue which allows items to be processed in order.

    • class ClosedError
      • public

      An error raised when trying to enqueue items to a closed queue.
  • class Reactor

    A wrapper around the the scheduler which binds it to the current thread automatically.
  • class Scheduler

    Handles scheduling of fibers. Implements the fiber scheduler interface.

    • class ClosedError

      Raised when an operation is attempted on a closed scheduler.
    • module BlockingOperationWait

      Used to augment the scheduler to add support for blocking operations.
    • class FiberInterrupt

      Used to defer stopping the current task until later.
  • class Semaphore
    • public

    A synchronization primitive, which limits access to a given resource.

    • class FiberNode
  • class Stop

    Raised when a task is explicitly stopped.

    • class Cause

      Represents the source of the stop operation.
    • class Later

      Used to defer stopping the current task until later.
  • class TimeoutError
    • public

    Raised if a timeout occurs on a specific Fiber. Handled gracefully by Task.
  • class Task
    • public
    • class FinishedError

      Raised when a child task is created within a task that has finished execution.
  • class Timeout
    • public

    Represents a flexible timeout that can be rescheduled or extended.

    • class CancelledError

      Raised when attempting to reschedule a cancelled timeout.
  • class Variable
    • deprecated

    A synchronization primitive that allows one task to wait for another task to resolve a value.
  • class Waiter
    • deprecated

    A composable synchronization primitive, which allows one task to wait for a number of other tasks to complete. It can be used in conjunction with class Async::Semaphore and/or class Async::Barrier.
• module Kernel

  Extensions to all Ruby objects.
• Provider