Search Results for

    Show / Hide Table of Contents

    Namespace Akka.Dispatch

    Classes

    ActionRunnable

    IRunnable which executes an Action

    ActionWithStateRunnable

    IRunnable which executes an Action<T> and an object representing the state.

    ActorTaskScheduler

    TBD

    BoundedDequeBasedMailbox

    BoundedDequeBasedMailbox is an bounded MailboxType backed by a double-ended queue. Used for stashing.

    BoundedMailbox

    The default bounded mailbox implementation

    ChannelTaskScheduler

    The Taskscheduler holds multiple TaskSchdulers with different priorities All scheduled work is executed over the regular ThreadPool and the execution sequence is depenedened on the priority of the TaskSchduler

    Priority TaskSchedulers: High => All queued work is processed before any other priority Normal => Normal work load, processed until max-work count Low => Only processed after normal work load Idle => only processed when no other work is queued

    ChannelTaskSchedulerProvider

    CurrentSynchronizationContextDispatcher

    Behaves like a PinnedDispatcher and always executes using Akka.Dispatch.CurrentSynchronizationContextExecutorServiceFactory

    DefaultDispatcherPrerequisites

    The default set of contextual data needed for MessageDispatcherConfigurators

    Dispatcher

    The event-based Dispatcher binds a set of actors to a thread pool backed up by a thread-safe queue.

    The preferred way of creating dispatchers is to define them in configuration and use the Lookup(string) method.

    DispatcherConfigurator

    The cached MessageDispatcher factory that gets looked up via configuration inside Dispatchers

    Dispatchers

    The registry of all MessageDispatcher instances available to this ActorSystem.

    Dispatchers are to be defined in configuration to allow for tuning for different environments. Use the Lookup(string) method to create a dispatcher as specified in configuration.

    A dispatcher config can also be an alias, in that case it is a config string value pointing to the actual dispatcher config.

    Look in akka.actor.default-dispatcher section of the reference.conf for documentation of dispatcher options.

    Not for user instantiation or extension

    ExecutorService

    Used by the Dispatcher to execute asynchronous invocations

    FutureActor

    Class FutureActor.

    Mailbox

    Mailbox base class

    MailboxType

    A factory to create IMessageQueues for an optionally provided IActorContext.

    Mailboxes

    Contains the directory of all MailboxTypes registered and configured with a given ActorSystem.

    MessageDispatcher

    Class responsible for pushing messages from an actor's mailbox into its receive methods. Comes in many different flavors.

    MessageDispatcherConfigurator

    Base class used for hooking new MessageDispatcher types into Dispatchers

    PinnedDispatcher

    Dedicates a unique thread for each actor passed in as reference. Served through its IMessageQueue.

    The preferred way of creating dispatcher is to define them in configuration and then use the Lookup(string) method.

    RejectedExecutionException

    Thrown when a ExecutorService implementation rejects

    ThreadPoolConfig

    Used inside Akka.Remote for constructing the low-level Helios threadpool, but inside vanilla Akka it's also used for constructing custom fixed-size-threadpool dispatchers.

    UnboundedDequeBasedMailbox

    UnboundedDequeBasedMailbox is an unbounded MailboxType backed by a double-ended queue. Used for stashing.

    UnboundedMailbox

    UnboundedMailbox is the default MailboxType used by Akka.NET Actors

    UnboundedPriorityMailbox

    Priority mailbox base class; unbounded mailbox that allows for prioritization of its contents. Extend this class and implement the PriorityGenerator(object) method with your own prioritization. The value returned by the PriorityGenerator(object) method will be used to order the message in the mailbox. Lower values will be delivered first. Messages ordered by the same number will remain in delivered in undefined order.

    UnboundedStablePriorityMailbox

    Priority mailbox - an unbounded mailbox that allows for prioritization of its contents. Extend this class and implement the PriorityGenerator(object) method with your own prioritization. The value returned by the PriorityGenerator(object) method will be used to order the message in the mailbox. Lower values will be delivered first. Messages ordered by the same number will remain in delivery order.

    Interfaces

    IBlockingMessageQueueSemantics

    Semantics for message queues that are blocking

    IBoundedDequeBasedMessageQueueSemantics

    Semantics for message queues that are Double-Ended and bounded

    IBoundedMessageQueueSemantics

    Semantics for message queues that have a bounded size

    IDequeBasedMessageQueueSemantics

    Semantics for message queues that are Double-Ended.

    IDispatcherPrerequisites

    Contextual information that's useful for dispatchers

    IMultipleConsumerSemantics

    Semantics for message queues that support multiple consumers

    IProducesMessageQueue<TQueue>

    Compliment to IRequiresMessageQueue<T>

    IProducesPushTimeoutSemanticsMailbox

    INTERNAL API

    Used to determine mailbox factories which create IBoundedMessageQueueSemantics mailboxes, and thus should be validated that the `pushTimeOut` is greater than 0.

    IRequiresMessageQueue<T>

    Interface to signal that an Actor requires a certain type of message queue semantics.

    The mailbox type will be looked up by mapping the type T via akka.actor.mailbox.requirements in the config, to a mailbox configuration. If no mailbox is assigned on Props or in deployment config then this one will be used.

    The queue type of the created mailbox will be checked against the type T and actor creation will fail if it doesn't fulfill the requirements.

    IRunnable

    An asynchronous operation will be executed by a MessageDispatcher.

    ISemantics

    Describes the message queue semantics of a mailbox.

    IUnboundedDequeBasedMessageQueueSemantics

    Semantics for message queues that are Double-Ended and unbounded

    IUnboundedMessageQueueSemantics

    Semantics for message queues that have an unbounded size

    Enums

    TaskSchedulerPriority

    Windows API related Process and Thread Priorities

    In this article
    Back to top
    Contribute
    • Project Chat
    • Discussion Forum
    • Source Code
    Support
    • Akka.NET Support Plans
    • Akka.NET Observability Tools
    • Akka.NET Training & Consulting
    Maintained By
    • Petabridge - The Akka.NET Company
    • Learn Akka.NET