|
|||||||||
| 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. |
| BalancingDispatcherConfigurator$ | INTERNAL API |
| 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$ | |
| CachingConfig$ | INTERNAL API |
| DefaultDispatcherPrerequisites$ | |
| DefaultExecutorServiceConfigurator | |
| 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.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> | |
| japi.CallbackBridge<T> | |
| japi.RecoverBridge<T> | |
| japi.UnitFunctionBridge<T> | |
| japi$ | This class contains bridge classes between Scala and Java. |
| Mailbox$ | INTERNAL API |
| 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$ | |
| 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 BalancingPool (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 | ||||||||