puniverse/quasar

Features

• Actor Models - Implements a complete actor model for managing isolated execution units through asynchronous message passing.
• Actor Models - Implements the actor model to provide isolated execution units that communicate via asynchronous message passing.
• Fiber-Based Concurrent Execution - Runs millions of lightweight, non-blocking fibers to achieve high concurrency with minimal resource overhead.
• Non-blocking I/O - Provides non-blocking I/O primitives that suspend lightweight fibers instead of blocking underlying system threads.
• Distributed Actor Frameworks - Provides a distributed actor system capable of operating across multiple cluster nodes with location transparency.
• Supervision Tree Management - Structures actors into hierarchical trees to define restart strategies and lifecycle dependencies for recovery.
• Behavior Implementations - Provides a framework for encapsulating state and logic within independent actors that communicate via asynchronous messaging.
• Request-Response Actor Patterns - Provides actors capable of processing synchronous calls with return values and asynchronous casts.
• Selective Message Filtering - Allows selecting specific messages from an actor's queue based on class, sender, or unique identifiers.
• Predicate-Based Message Selection - Retrieves specific messages from a mailbox based on predicates to simplify state machine logic.
• Asynchronous Communication Channels - Implements asynchronous communication channels for messaging between isolated execution environments.
• Actor Message Handlings - Provides mechanisms to intercept and process every message sent to a specific actor via custom handlers.
• Type-Based Message Selection - Retrieves specific messages from a mailbox based on type, ignoring others until a match is found.
• Non-Blocking Suspension Points - Pauses the current fiber during I/O operations and resumes it only when data readiness is notified.
• Green Threads - Utilizes green-thread style fibers to minimize memory overhead compared to standard OS threads.
• JVM Concurrency Frameworks - Offers a comprehensive toolkit for JVM concurrency using fibers, channels, and the actor model.
• Work-Stealing Schedulers - Utilizes a work-stealing scheduler to distribute lightweight fibers across worker threads for optimal CPU utilization.
• Fiber-Based Schedulers - Manages lightweight thread execution via a cooperative scheduler using a configurable pool of worker threads.
• Actor Name Registries - Retrieves registered actors using unique names via a location-transparent registry.
• Actor Name Registrations - Assigns public names to actors to make them discoverable via local or cluster-wide registries.
• Non-blocking IO Implementations - Implements non-blocking network and file I/O that suspends fibers instead of blocking system threads.
• Actor-Based Concurrency - Utilizes isolated, message-passing actors to manage state and concurrent execution.
• Suspendable Execution - Allows tasks to suspend during non-blocking I/O operations without stalling underlying system threads.
• Fiber Spawning - Spawns memory-efficient fibers within a worker pool to minimize system overhead during task creation.
• Worker Pool Schedulers - Implements a work-stealing scheduler to distribute lightweight fiber tasks across a pool of worker threads.
• CSP Communication Channels - Provides a set of CSP-style primitives for synchronizing data flow between concurrent tasks.
• Fault Tolerance - Employs isolated execution units and message passing to ensure resilience and fault tolerance in distributed applications.
• Hierarchy Supervision - Implements supervisory hierarchies that detect child actor failures and execute automated restart strategies.
• Recovery Strategies - Defines supervisor reactions to child failures through strategies like restarting specific actors or escalating errors.
• Request-Reply Patterns - Implements synchronous-style communication between actors by suspending execution until a response is received.
• Request-Response Pattern Support - Facilitates synchronous communication where a requester blocks until an actor processes a message and replies.
• State Migration - Enables the relocation of actor identities and internal states between cluster nodes to optimize availability and load balancing.
• Type-Based Message Routing - Implements type-based filtering to retrieve messages of a specific class from an actor's mailbox.
• Linking and Watching - Monitors actor lifecycles to trigger exceptions or notifications when a linked actor terminates.
• Actor-Based Message Routing - Attaches sender references and identifiers to messages to enable precise routing of replies.
• Mailbox Capacity Management - Enables setting maximum message capacities for actor queues and defining overflow strategies.
• Channel Message Transmission - Transmits data to a consumer with options to block, timeout, or attempt a non-blocking send.
• Message Consumption - Supports retrieving messages from communication ports using blocking or non-blocking polling.
• Cluster Message Dispatchers - Dispatches asynchronous messages between actors across a cluster without blocking the sender.
• Pattern Templates - Provides standardized templates for actor lifecycles and message handling to encapsulate complex concurrency patterns.
• Location Transparency - Provides a location-transparent registry that maps actor names to units across local or remote cluster nodes.
• Hierarchy Management - Controls child actor lifecycles through creation, retrieval, and removal within a supervisory relationship.
• Actor Exit Signal Trapping - Converts actor termination signals into manageable messages to prevent cascading failures during the lifecycle process.
• Graceful Actor Terminations - Provides mechanisms to trigger an actor's own termination process through a specialized shutdown signal.
• Death Notifications - Sends lifecycle messages and exception causes to linked actors or watchers when an actor terminates.
• Lifecycle Monitoring - Provides automatic notifications to watchers or linked entities when an actor experiences a termination event.
• Lifecycle Controllers - Provides a unified control interface to manage the state and lifecycle of lightweight fibers and standard threads.
• Hot Code Swapping - Allows updating actor behaviors at runtime without requiring a full system restart.
• Supervision Configurations - Defines restart limits, failure time windows, and shutdown deadlines to manage the recovery of child actors.
• Channel-Based Concurrency - Uses CSP-style communication channels to synchronize data exchange and propagate changes between concurrent tasks.
• Node Clustering - Connects actor instances across multiple machines into a cluster to share workload and state.
• Fiber State Serializers - Allows pausing and converting fiber execution state into byte streams for node migration or persistence.
• Dataflow Graph Management - Manages values updated by concurrent strands that automatically propagate changes through a dataflow dependency graph.
• Dataflow Variable Coordination - Implements dataflow variables that block readers until a value is set and automatically trigger re-computation of dependent variables.
• Supervisory Hierarchies - Implements supervisory hierarchies for fault-tolerant recovery by defining automated restart strategies for failing child actors.
• Finite State Machine Actors - Provides actors that manage a sequence of states where each state processes logic and determines the next state transition.
• Message Passing Channels - Provides synchronized communication primitives for exchanging data between concurrent tasks.
• Channel Data Transformation - Provides capabilities to modify or filter messages passing through channels to produce new data streams.
• Multi-Channel Selection - Implements a select operation to execute the first available send or receive from multiple channels.
• Actor State Machine Modeling - Builds actors that transition between different states using callable logic to determine the next state.
• Actor State Migration - Moves running actors between cluster nodes while preserving their internal state to optimize load and availability.
• Synchronous Event Dispatchers - Routes incoming events to handlers that execute synchronously on the actor's processing strand.
• Synchronous Request-Response Loops - Allows sending a request to an actor and blocking the calling fiber until a response is received.
• Future-Based Result Tracking - Tracks the eventual result of asynchronous operations and blocks the calling fiber until the value is available.
• Common Frameworks - Provides fibers, channels, and actors for high-concurrency JVM applications.

Star history