Which sender is captured inside Actor message handler? - scala

Question

I'm a novice to Akka actors, and I did some experiment as below to learn how actors work.
class RequestActor extends Actor with ActorLogging {
import RequestActor._
implicit val timeout = Timeout(15.seconds)
implicit val ec: ExecutionContext = context.dispatcher
override def receive: Receive = {
case Request(name) =>
// self ? TempRequest(TempRequest(name), xxx) pipeTo sender // Q1: if we reference `sender` here, which `sender` will be captured?
self ? TempRequest(name, sender) onComplete {
// val whichSender = sender // Q2: if we reference `sender` here, which `sender` will be captured?
case Success(TempResponse(msg, origin)) => origin ! HelloReply(msg)
case Failure(ex) => ???
}
case TempRequest(name, origin) =>
sender ! TempReply(s"hello, ${name}!", origin)
case _ =>
???
}
}
I understand we should prefer tell to ask. I made up this example trying to clear several confusions:
Q1 - Q2) I know sender is actually context.sender(). As the comment inside the code snippet, which sender will be captured?
My confusion is, will the sender be the right one resulting in the corresponding ask operation? Or could it be the sender of a message coming later?
3) Will actors be able to continue processing new messages while they're waiting for the reply of the ask?
From the experiment, it seems so. Could anyone please confirm this?
Thanks so much!

Answer 1

// self ? TempRequest(TempRequest(name), xxx) pipeTo sender // Q1: if we reference sender here, which sender will be captured?
The sender of message Request. This is not visible in your snippet.
From comment
self ? TempRequest(TempRequest(name), xxx) pipeTo sender. As this is an ask and waiting will occur, before the response is received, another message could be received by the actor, and thus cause the sender to be change. So, isn't it possible that the pipeTo sender causes the response to send to a wrong actor?
pipeTo pattern will register a callback for the future returned by ? or ask pattern. The callback will reference the sender returned by sender() at the time of callback registration, which is done in blocking manner when Request message is processed. Thus the sender() is the sender of Request message.
pipeTo excludes any possibility of actor context leakage and this is one of the reasons it should be used.
// val whichSender = sender // Q2: if we reference sender here, which sender will be captured?
This will actually cause a bug or leakage of actor context outside of an actor and must not be done. It can be done with a local reference like in following code
case Request(name) =>
val requestSender = context.sender()
self ? TempRequest(name) onComplete {
case Success(TempResponse(msg)) => requestSender ! HelloReply(msg)
}
From docs
When using future callbacks, such as onComplete, or map such as thenRun, or thenApply inside actors you need to carefully avoid closing over the containing actor’s reference, 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.
And finally
3) Will actors be able to continue processing new messages while they're waiting for the reply of the ask?
Yes. There is no "waiting" process. It just registers a callback that is executed outside the actor. Thus the problem of possible actor context leakage.
Additionally,
You could use forward that preserves the original messages sender. And your code can be simplified as following
override def receive: Receive = {
case Request(name) =>
self.forward(TempRequest(name))
case TempRequest(name) =>
sender() ! HelloReply(s"hello, ${name}!"))
}