Overview

• module Async

  Asynchronous programming framework.

  • 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.

    • class FiberNode
  • module Console

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

    A load balancing mechanism that can be used process work when the system is idle.
  • 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 Queue
    • public

    A queue which allows items to be processed in order.
  • class LimitedQueue
    • public

    A queue which limits the number of items that can be enqueued.
  • 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.
  • 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 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 Variable

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

    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.
  • class Wrapper
    • deprecated

    Represents an asynchronous IO within a reactor.

    • class Cancelled

      An exception that occurs when the asynchronous operation was cancelled.
• module Kernel

  Extensions to all Ruby objects.
• Provider