public class Patterns$
extends java.lang.Object
Modifier and Type | Field and Description |
---|---|
static Patterns$ |
MODULE$
Static reference to the singleton instance of this Scala object.
|
Constructor and Description |
---|
Patterns$() |
Modifier and Type | Method and Description |
---|---|
<T> scala.concurrent.Future<T> |
after(scala.concurrent.duration.FiniteDuration duration,
Scheduler scheduler,
scala.concurrent.ExecutionContext context,
java.util.concurrent.Callable<scala.concurrent.Future<T>> value)
Returns a
Future that will be completed with the success or failure of the provided Callable
after the specified duration. |
<T> scala.concurrent.Future<T> |
after(scala.concurrent.duration.FiniteDuration duration,
Scheduler scheduler,
scala.concurrent.ExecutionContext context,
scala.concurrent.Future<T> value)
Returns a
Future that will be completed with the success or failure of the provided Callable
after the specified duration. |
scala.concurrent.Future<java.lang.Object> |
ask(ActorRef actor,
Function<ActorRef,java.lang.Object> messageFactory,
long timeoutMillis)
A variation of ask which allows to implement "replyTo" pattern by including
sender reference in message.
|
scala.concurrent.Future<java.lang.Object> |
ask(ActorRef actor,
Function<ActorRef,java.lang.Object> messageFactory,
Timeout timeout)
A variation of ask which allows to implement "replyTo" pattern by including
sender reference in message.
|
scala.concurrent.Future<java.lang.Object> |
ask(ActorRef actor,
java.lang.Object message,
long timeoutMillis)
Java API for
akka.pattern.ask :
Sends a message asynchronously and returns a Future
holding the eventual reply message; this means that the target actor
needs to send the result to the sender reference provided. |
scala.concurrent.Future<java.lang.Object> |
ask(ActorRef actor,
java.lang.Object message,
Timeout timeout)
Java API for
akka.pattern.ask :
Sends a message asynchronously and returns a Future
holding the eventual reply message; this means that the target actor
needs to send the result to the sender reference provided. |
scala.concurrent.Future<java.lang.Object> |
ask(ActorSelection selection,
Function<ActorRef,java.lang.Object> messageFactory,
long timeoutMillis)
A variation of ask which allows to implement "replyTo" pattern by including
sender reference in message.
|
scala.concurrent.Future<java.lang.Object> |
ask(ActorSelection selection,
java.lang.Object message,
long timeoutMillis)
Java API for
akka.pattern.ask :
Sends a message asynchronously and returns a Future
holding the eventual reply message; this means that the target ActorSelection
needs to send the result to the sender reference provided. |
scala.concurrent.Future<java.lang.Object> |
ask(ActorSelection selection,
java.lang.Object message,
Timeout timeout)
Java API for
akka.pattern.ask :
Sends a message asynchronously and returns a Future
holding the eventual reply message; this means that the target ActorSelection
needs to send the result to the sender reference provided. |
scala.concurrent.Future<java.lang.Boolean> |
gracefulStop(ActorRef target,
scala.concurrent.duration.FiniteDuration timeout)
Returns a
Future that will be completed with success (value true ) when
existing messages of the target actor has been processed and the actor has been
terminated. |
scala.concurrent.Future<java.lang.Boolean> |
gracefulStop(ActorRef target,
scala.concurrent.duration.FiniteDuration timeout,
java.lang.Object stopMessage)
Returns a
Future that will be completed with success (value true ) when
existing messages of the target actor has been processed and the actor has been
terminated. |
<T> PipeToSupport.PipeableFuture<T> |
pipe(scala.concurrent.Future<T> future,
scala.concurrent.ExecutionContext context)
Register an onComplete callback on this
Future to send
the result to the given ActorRef or ActorSelection . |
public static final Patterns$ MODULE$
public scala.concurrent.Future<java.lang.Object> ask(ActorRef actor, java.lang.Object message, Timeout timeout)
akka.pattern.ask
:
Sends a message asynchronously and returns a Future
holding the eventual reply message; this means that the target actor
needs to send the result to the sender
reference provided. The Future
will be completed with an AskTimeoutException
after the
given timeout has expired; this is independent from any timeout applied
while awaiting a result for this future (i.e. in
Await.result(..., timeout)
).
Warning: When using future callbacks, inside actors you need to carefully avoid closing over the containing actor’s object, i.e. do not call methods or access mutable state on the enclosing actor from within the callback. This would break the actor encapsulation and may introduce synchronization bugs and race conditions because the callback will be scheduled concurrently to the enclosing actor. Unfortunately there is not yet a way to detect these illegal accesses at compile time.
Recommended usage:
final Future<Object> f = Patterns.ask(worker, request, timeout);
f.onSuccess(new Procedure<Object>() {
public void apply(Object o) {
nextActor.tell(new EnrichedResult(request, o));
}
});
actor
- (undocumented)message
- (undocumented)timeout
- (undocumented)public scala.concurrent.Future<java.lang.Object> ask(ActorRef actor, Function<ActorRef,java.lang.Object> messageFactory, Timeout timeout)
final Future<Object> f = Patterns.ask(
worker,
new akka.japi.Function<ActorRef, Object> {
Object apply(ActorRef askSender) {
return new Request(askSender);
}
},
timeout);
actor
- (undocumented)messageFactory
- (undocumented)timeout
- (undocumented)public scala.concurrent.Future<java.lang.Object> ask(ActorRef actor, java.lang.Object message, long timeoutMillis)
akka.pattern.ask
:
Sends a message asynchronously and returns a Future
holding the eventual reply message; this means that the target actor
needs to send the result to the sender
reference provided. The Future
will be completed with an AskTimeoutException
after the
given timeout has expired; this is independent from any timeout applied
while awaiting a result for this future (i.e. in
Await.result(..., timeout)
).
Warning: When using future callbacks, inside actors you need to carefully avoid closing over the containing actor’s object, i.e. do not call methods or access mutable state on the enclosing actor from within the callback. This would break the actor encapsulation and may introduce synchronization bugs and race conditions because the callback will be scheduled concurrently to the enclosing actor. Unfortunately there is not yet a way to detect these illegal accesses at compile time.
Recommended usage:
final Future<Object> f = Patterns.ask(worker, request, timeout);
f.onSuccess(new Procedure<Object>() {
public void apply(Object o) {
nextActor.tell(new EnrichedResult(request, o));
}
});
actor
- (undocumented)message
- (undocumented)timeoutMillis
- (undocumented)public scala.concurrent.Future<java.lang.Object> ask(ActorRef actor, Function<ActorRef,java.lang.Object> messageFactory, long timeoutMillis)
final Future<Object> f = Patterns.ask(
worker,
new akka.japi.Function<ActorRef, Object> {
Object apply(ActorRef askSender) {
return new Request(askSender);
}
},
timeout);
actor
- (undocumented)messageFactory
- (undocumented)timeoutMillis
- (undocumented)public scala.concurrent.Future<java.lang.Object> ask(ActorSelection selection, java.lang.Object message, Timeout timeout)
akka.pattern.ask
:
Sends a message asynchronously and returns a Future
holding the eventual reply message; this means that the target ActorSelection
needs to send the result to the sender
reference provided. The Future
will be completed with an AskTimeoutException
after the
given timeout has expired; this is independent from any timeout applied
while awaiting a result for this future (i.e. in
Await.result(..., timeout)
).
Warning: When using future callbacks, inside actors you need to carefully avoid closing over the containing actor’s object, i.e. do not call methods or access mutable state on the enclosing actor from within the callback. This would break the actor encapsulation and may introduce synchronization bugs and race conditions because the callback will be scheduled concurrently to the enclosing actor. Unfortunately there is not yet a way to detect these illegal accesses at compile time.
Recommended usage:
final Future<Object> f = Patterns.ask(selection, request, timeout);
f.onSuccess(new Procedure<Object>() {
public void apply(Object o) {
nextActor.tell(new EnrichedResult(request, o));
}
});
selection
- (undocumented)message
- (undocumented)timeout
- (undocumented)public scala.concurrent.Future<java.lang.Object> ask(ActorSelection selection, java.lang.Object message, long timeoutMillis)
akka.pattern.ask
:
Sends a message asynchronously and returns a Future
holding the eventual reply message; this means that the target ActorSelection
needs to send the result to the sender
reference provided. The Future
will be completed with an AskTimeoutException
after the
given timeout has expired; this is independent from any timeout applied
while awaiting a result for this future (i.e. in
Await.result(..., timeout)
).
Warning: When using future callbacks, inside actors you need to carefully avoid closing over the containing actor’s object, i.e. do not call methods or access mutable state on the enclosing actor from within the callback. This would break the actor encapsulation and may introduce synchronization bugs and race conditions because the callback will be scheduled concurrently to the enclosing actor. Unfortunately there is not yet a way to detect these illegal accesses at compile time.
Recommended usage:
final Future<Object> f = Patterns.ask(selection, request, timeout);
f.onSuccess(new Procedure<Object>() {
public void apply(Object o) {
nextActor.tell(new EnrichedResult(request, o));
}
});
selection
- (undocumented)message
- (undocumented)timeoutMillis
- (undocumented)public scala.concurrent.Future<java.lang.Object> ask(ActorSelection selection, Function<ActorRef,java.lang.Object> messageFactory, long timeoutMillis)
final Future<Object> f = Patterns.ask(
selection,
new akka.japi.Function<ActorRef, Object> {
Object apply(ActorRef askSender) {
return new Request(askSender);
}
},
timeout);
selection
- (undocumented)messageFactory
- (undocumented)timeoutMillis
- (undocumented)public <T> PipeToSupport.PipeableFuture<T> pipe(scala.concurrent.Future<T> future, scala.concurrent.ExecutionContext context)
Future
to send
the result to the given ActorRef
or ActorSelection
.
Returns the original Future to allow method chaining.
If the future was completed with failure it is sent as a Status.Failure
to the recipient.
Recommended usage example:
final Future<Object> f = Patterns.ask(worker, request, timeout);
// apply some transformation (i.e. enrich with request info)
final Future<Object> transformed = f.map(new akka.japi.Function<Object, Object>() { ... });
// send it on to the next stage
Patterns.pipe(transformed).to(nextActor);
future
- (undocumented)context
- (undocumented)public scala.concurrent.Future<java.lang.Boolean> gracefulStop(ActorRef target, scala.concurrent.duration.FiniteDuration timeout)
Future
that will be completed with success (value true
) when
existing messages of the target actor has been processed and the actor has been
terminated.
Useful when you need to wait for termination or compose ordered termination of several actors.
If the target actor isn't terminated within the timeout the Future
is completed with failure AskTimeoutException
.
target
- (undocumented)timeout
- (undocumented)public scala.concurrent.Future<java.lang.Boolean> gracefulStop(ActorRef target, scala.concurrent.duration.FiniteDuration timeout, java.lang.Object stopMessage)
Future
that will be completed with success (value true
) when
existing messages of the target actor has been processed and the actor has been
terminated.
Useful when you need to wait for termination or compose ordered termination of several actors.
If you want to invoke specialized stopping logic on your target actor instead of PoisonPill, you can pass your
stop command as stopMessage
parameter
If the target actor isn't terminated within the timeout the Future
is completed with failure AskTimeoutException
.
target
- (undocumented)timeout
- (undocumented)stopMessage
- (undocumented)public <T> scala.concurrent.Future<T> after(scala.concurrent.duration.FiniteDuration duration, Scheduler scheduler, scala.concurrent.ExecutionContext context, java.util.concurrent.Callable<scala.concurrent.Future<T>> value)
Future
that will be completed with the success or failure of the provided Callable
after the specified duration.duration
- (undocumented)scheduler
- (undocumented)context
- (undocumented)value
- (undocumented)public <T> scala.concurrent.Future<T> after(scala.concurrent.duration.FiniteDuration duration, Scheduler scheduler, scala.concurrent.ExecutionContext context, scala.concurrent.Future<T> value)
Future
that will be completed with the success or failure of the provided Callable
after the specified duration.duration
- (undocumented)scheduler
- (undocumented)context
- (undocumented)value
- (undocumented)