| Interface | Description |
|---|---|
| Batchable |
All Batchables are automatically batched when submitted to a BatchingExecutor
|
| BatchingExecutor |
Mixin trait for an Executor
which groups multiple nested
Runnable.run() calls
into a single Runnable passed to the original
Executor. |
| BoundedControlAwareMessageQueueSemantics | |
| BoundedDequeBasedMessageQueue |
BoundedMessageQueueSemantics adds bounded semantics to a DequeBasedMessageQueue,
i.e.
|
| BoundedDequeBasedMessageQueueSemantics | |
| BoundedMessageQueueSemantics |
BoundedMessageQueueSemantics adds bounded semantics to a QueueBasedMessageQueue,
i.e.
|
| BoundedQueueBasedMessageQueue | |
| CachingConfig.PathEntry | |
| ControlAwareMessageQueueSemantics |
ControlAwareMessageQueue handles messages that extend
ControlMessage with priority. |
| ControlMessage |
Messages that extend this trait will be handled with priority by control aware mailboxes.
|
| DefaultSystemMessageQueue |
INTERNAL API
|
| DequeBasedMessageQueue | |
| DequeBasedMessageQueueSemantics |
DequeBasedMessageQueue refines QueueBasedMessageQueue to be backed by a java.util.Deque.
|
| DispatcherPrerequisites |
DispatcherPrerequisites represents useful contextual pieces when constructing a MessageDispatcher
|
| ExecutorServiceDelegate |
As the name says
|
| ExecutorServiceFactory | |
| ExecutorServiceFactoryProvider | |
| LoadMetrics |
INTERNAL API
|
| MailboxType |
MailboxType is a factory to create MessageQueues for an optionally
provided ActorContext.
|
| MessageQueue |
A MessageQueue is one of the core components in forming an Akka Mailbox.
|
| MultipleConsumerSemantics |
This is a marker trait for message queues which support multiple consumers,
as is required by the BalancingDispatcher.
|
| ProducesMessageQueue<T extends MessageQueue> | |
| ProducesPushTimeoutSemanticsMailbox |
INTERNAL API
Used to determine mailbox factories which create
BoundedMessageQueueSemantics
mailboxes, and thus should be validated that the pushTimeOut is greater than 0. |
| QueueBasedMessageQueue |
A QueueBasedMessageQueue is a MessageQueue backed by a java.util.Queue.
|
| RequiresMessageQueue<T> |
Trait to signal that an Actor requires a certain type of message queue semantics.
|
| SystemMessageQueue |
INTERNAL API
|
| UnboundedControlAwareMessageQueueSemantics | |
| UnboundedDequeBasedMessageQueue |
UnboundedDequeBasedMessageQueueSemantics adds unbounded semantics to a DequeBasedMessageQueue,
i.e.
|
| UnboundedDequeBasedMessageQueueSemantics | |
| UnboundedMessageQueueSemantics |
UnboundedMessageQueueSemantics adds unbounded semantics to a QueueBasedMessageQueue,
i.e.
|
| UnboundedQueueBasedMessageQueue |
| Class | Description |
|---|---|
| AbstractBoundedNodeQueue<T> |
Lock-free bounded non-blocking multiple-producer single-consumer queue based on the works of:
Andriy Plokhotnuyk (https://github.com/plokhotnyuk)
- https://github.com/plokhotnyuk/actors/blob/2e65abb7ce4cbfcb1b29c98ee99303d6ced6b01f/src/test/scala/akka/dispatch/Mailboxes.scala
(Apache V2: https://github.com/plokhotnyuk/actors/blob/master/LICENSE)
Dmitriy Vyukov's non-intrusive MPSC queue:
- http://www.1024cores.net/home/lock-free-algorithms/queues/non-intrusive-mpsc-node-based-queue
(Simplified BSD)
|
| AbstractBoundedNodeQueue.Node<T> | |
| AbstractNodeQueue<T> |
Lock-free MPSC linked queue implementation based on Dmitriy Vyukov's non-intrusive MPSC queue:
http://www.1024cores.net/home/lock-free-algorithms/queues/non-intrusive-mpsc-node-based-queue
This queue could be wait-free (i.e.
|
| AbstractNodeQueue.Node<T> | |
| BalancingDispatcher | Deprecated
Use BalancingPool instead of BalancingDispatcher.
|
| BalancingDispatcherConfigurator |
Configurator for creating
BalancingDispatcher. |
| BalancingDispatcherConfigurator$ |
INTERNAL API
|
| BatchingExecutor.AbstractBatch | |
| BatchingExecutor.Batch | |
| BatchingExecutor.BlockableBatch | |
| BoundedControlAwareMailbox |
BoundedControlAwareMailbox is a bounded MailboxType, that maintains two queues
to allow messages that extend
ControlMessage to be delivered with priority. |
| BoundedControlAwareMailbox.MessageQueue | |
| BoundedControlAwareMailbox$ | |
| BoundedDequeBasedMailbox |
BoundedDequeBasedMailbox is an bounded MailboxType, backed by a Deque.
|
| BoundedDequeBasedMailbox.MessageQueue | |
| BoundedDequeBasedMailbox$ | |
| BoundedMailbox |
BoundedMailbox is the default bounded MailboxType used by Akka Actors.
|
| BoundedMailbox.MessageQueue | |
| BoundedMailbox$ | |
| BoundedNodeMessageQueue |
Lock-free bounded non-blocking multiple-producer single-consumer queue.
|
| BoundedPriorityMailbox |
BoundedPriorityMailbox is a bounded mailbox that allows for prioritization of its contents.
|
| BoundedPriorityMailbox.MessageQueue | |
| BoundedPriorityMailbox$ | |
| BoundedStablePriorityMailbox |
BoundedStablePriorityMailbox is a bounded mailbox that allows for prioritization of its contents.
|
| BoundedStablePriorityMailbox.MessageQueue | |
| BoundedStablePriorityMailbox$ | |
| CachingConfig |
INTERNAL API
|
| CachingConfig.StringPathEntry | |
| CachingConfig.StringPathEntry$ | |
| CachingConfig.ValuePathEntry | |
| CachingConfig.ValuePathEntry$ | |
| CachingConfig$ |
INTERNAL API
|
| DefaultDispatcherPrerequisites |
INTERNAL API
|
| DefaultDispatcherPrerequisites$ | |
| DefaultExecutorServiceConfigurator | |
| Dispatcher |
The event-based
BlockingQueue. |
| DispatcherConfigurator |
Configurator for creating
Dispatcher. |
| Dispatchers |
Dispatchers are to be defined in configuration to allow for tuning
for different environments.
|
| Dispatchers$ | |
| Envelope | |
| Envelope$ | |
| ExecutionContexts |
ExecutionContexts is the Java API for ExecutionContexts
|
| ExecutionContexts.sameThreadExecutionContext$ |
WARNING: Not A General Purpose ExecutionContext!
|
| ExecutionContexts$ |
ExecutionContexts is the Java API for ExecutionContexts
|
| ExecutorServiceConfigurator |
An ExecutorServiceConfigurator is a class that given some prerequisites and a configuration can create instances of ExecutorService
|
| Filter |
Java API (not recommended):
Callback for the Future.filter operation that creates a new Future which will
conditionally contain the success of another Future.
|
| Filter$ |
Java API (not recommended):
Callback for the Future.filter operation that creates a new Future which will
conditionally contain the success of another Future.
|
| Foreach<T> |
Callback for the Future.foreach operation that will be invoked if the Future that this callback
is registered on becomes completed with a success.
|
| ForkJoinExecutorConfigurator | |
| ForkJoinExecutorConfigurator.AkkaForkJoinPool |
INTERNAL AKKA USAGE ONLY
|
| ForkJoinExecutorConfigurator.AkkaForkJoinTask |
INTERNAL AKKA USAGE ONLY
|
| ForkJoinExecutorConfigurator$ | |
| Futures |
Futures is the Java API for Futures and Promises
|
| Futures$ |
Futures is the Java API for Futures and Promises
|
| japi |
This class contains bridge classes between Scala and Java.
|
| japi.BooleanFunctionBridge<T> | Deprecated
Do not use this directly, use subclasses of this.
|
| japi.CallbackBridge<T> | Deprecated
Do not use this directly, use subclasses of this.
|
| japi.RecoverBridge<T> | Deprecated
Do not use this directly, use 'Recover'.
|
| japi.UnitFunctionBridge<T> | Deprecated
Do not use this directly, use subclasses of this.
|
| japi$ |
This class contains bridge classes between Scala and Java.
|
| Mailbox |
Mailbox and InternalMailbox is separated in two classes because ActorCell is needed for implementation,
but can't be exposed to user defined mailbox subclasses.
|
| Mailbox$ |
INTERNAL API
|
| Mailboxes | |
| Mailboxes$ | |
| Mapper<T,R> |
Callback for the Future.map and Future.flatMap operations that will be invoked
if the Future that this callback is registered on becomes completed with a success.
|
| MessageDispatcher | |
| MessageDispatcher$ |
INTERNAL API
|
| MessageDispatcherConfigurator |
Base class to be used for hooking in new dispatchers into Dispatchers.
|
| MonitorableThreadFactory | |
| MonitorableThreadFactory.AkkaForkJoinWorkerThread | |
| MonitorableThreadFactory$ | |
| NodeMessageQueue | |
| NonBlockingBoundedMailbox |
NonBlockingBoundedMailbox is a high-performance, multiple-producer single-consumer, bounded MailboxType,
Noteworthy is that it discards overflow as DeadLetters.
|
| NonBlockingBoundedMailbox$ | |
| OnComplete<T> |
Callback for when a Future is completed with either failure or a success
SAM (Single Abstract Method) class
|
| OnFailure |
Callback for when a Future is completed with a failure
SAM (Single Abstract Method) class
|
| OnSuccess<T> |
Callback for when a Future is completed successfully
SAM (Single Abstract Method) class
|
| PinnedDispatcher |
Dedicates a unique thread for each actor passed in as reference.
|
| PinnedDispatcherConfigurator |
Configurator for creating
PinnedDispatcher. |
| PriorityGenerator |
A PriorityGenerator is a convenience API to create a Comparator that orders the messages of a
PriorityDispatcher
|
| PriorityGenerator$ | |
| Recover<T> |
Callback for the Future.recover operation that conditionally turns failures into successes.
|
| SaneRejectedExecutionHandler |
The RejectedExecutionHandler used by Akka, it improves on CallerRunsPolicy
by throwing a RejectedExecutionException if the executor isShutdown.
|
| SingleConsumerOnlyUnboundedMailbox |
SingleConsumerOnlyUnboundedMailbox is a high-performance, multiple producer—single consumer, unbounded MailboxType,
with the drawback that you can't have multiple consumers,
which rules out using it with BalancingPool (BalancingDispatcher) for instance.
|
| SingleConsumerOnlyUnboundedMailbox$ | |
| TaskInvocation | |
| TaskInvocation$ | |
| ThreadPoolConfig | |
| ThreadPoolConfig$ | |
| ThreadPoolConfigBuilder |
A DSL to configure and create a MessageDispatcher with a ThreadPoolExecutor
|
| ThreadPoolConfigBuilder$ | |
| ThreadPoolExecutorConfigurator | |
| UnboundedControlAwareMailbox |
UnboundedControlAwareMailbox is an unbounded MailboxType, that maintains two queues
to allow messages that extend
ControlMessage to be delivered with priority. |
| UnboundedControlAwareMailbox.MessageQueue | |
| UnboundedControlAwareMailbox$ | |
| UnboundedDequeBasedMailbox |
UnboundedDequeBasedMailbox is an unbounded MailboxType, backed by a Deque.
|
| UnboundedDequeBasedMailbox.MessageQueue | |
| UnboundedDequeBasedMailbox$ | |
| UnboundedMailbox |
UnboundedMailbox is the default unbounded MailboxType used by Akka Actors.
|
| UnboundedMailbox.MessageQueue | |
| UnboundedMailbox$ | |
| UnboundedPriorityMailbox |
UnboundedPriorityMailbox is an unbounded mailbox that allows for prioritization of its contents.
|
| UnboundedPriorityMailbox.MessageQueue | |
| UnboundedPriorityMailbox$ | |
| UnboundedStablePriorityMailbox |
UnboundedStablePriorityMailbox is an unbounded mailbox that allows for prioritization of its contents.
|
| UnboundedStablePriorityMailbox.MessageQueue | |
| UnboundedStablePriorityMailbox$ |