|
|||||||||
PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
Interface Summary | |
---|---|
BoundedDequeBasedMessageQueue | BoundedMessageQueueSemantics adds bounded semantics to a DequeBasedMessageQueue, i.e. |
BoundedDequeBasedMessageQueueSemantics | |
BoundedMessageQueueSemantics | BoundedMessageQueueSemantics adds bounded semantics to a QueueBasedMessageQueue, i.e. |
BoundedQueueBasedMessageQueue | |
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 | Function0 without the fun stuff (mostly for the sake of the Java API side of things) |
ExecutorServiceFactoryProvider | Generic way to specify an ExecutorService to a Dispatcher, create it with the given name if desired |
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> | |
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. |
UnboundedDequeBasedMessageQueue | UnboundedDequeBasedMessageQueueSemantics adds unbounded semantics to a DequeBasedMessageQueue, i.e. |
UnboundedDequeBasedMessageQueueSemantics | |
UnboundedMessageQueueSemantics | UnboundedMessageQueueSemantics adds unbounded semantics to a QueueBasedMessageQueue, i.e. |
UnboundedQueueBasedMessageQueue |
Class Summary | |
---|---|
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 |
AbstractNodeQueue.Node<T> | |
BalancingDispatcher | An executor based event driven dispatcher which will try to redistribute work from busy actors to idle actors. |
BalancingDispatcherConfigurator | Configurator for creating BalancingDispatcher . |
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$ | |
BoundedPriorityMailbox | BoundedPriorityMailbox is a bounded mailbox that allows for prioritization of its contents. |
BoundedPriorityMailbox.MessageQueue | |
BoundedPriorityMailbox$ | |
Dispatcher | The event-based Dispatcher binds a set of Actors to a thread pool backed up by a
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$ | 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> | |
japi.CallbackBridge<T> | |
japi.RecoverBridge<T> | |
japi.UnitFunctionBridge<T> | |
japi$ | This class contains bridge classes between Scala and Java. |
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 | |
MessageDispatcherConfigurator | Base class to be used for hooking in new dispatchers into Dispatchers. |
MonitorableThreadFactory | |
MonitorableThreadFactory$ | |
NodeMessageQueue | |
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, the only drawback is that you can't have multiple consumers, which rules out using it with BalancingDispatcher for instance. |
SingleConsumerOnlyUnboundedMailbox$ | |
TaskInvocation | |
TaskInvocation$ | |
ThreadPoolConfig | A small configuration DSL to create ThreadPoolExecutors that can be provided as an ExecutorServiceFactoryProvider to Dispatcher |
ThreadPoolConfig$ | |
ThreadPoolConfigBuilder | A DSL to configure and create a MessageDispatcher with a ThreadPoolExecutor |
ThreadPoolConfigBuilder$ | |
ThreadPoolExecutorConfigurator | |
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$ |
|
|||||||||
PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |