Difference between forward and tell in akka actors

Question

What is a difference between tell and forward, in case I will send the same message:

case msg: Message =>
  otherActor tell (msg,sender)

and

case msg: Message =>
  otherActor forward msg

score 122 · Accepted Answer · edited May 16 '16 at 12:50

122

The sender() will be different on the receiving end.

Message sends using tell (also known as !):

A tells message M to B.
B tells that message to C.
C thinks the sender() of message M is B.

Message sends using forward:

A tells message M to B.
B forwards that message to C.
C thinks the sender() of message M is A.

Worth pointing out is, that you can achieve the same as forward when explicitly setting the sender of a message using tell, however this is not typical Akka-style:

// inside `B`, when received `msg` from `A`
C tell (msg, A) 
      == 
C forward msg

For more info refer to the docs about forward.

edited May 16 '16 at 12:50

Marcin Świerczyński

2,302
22
32

answered Aug 04 '14 at 09:36

Konrad 'ktoso' Malawski

13,102
3
47
52

6

Actually in his case above, he uses `tell(msg,sender)`, which then is the equivalent to forward. Right? – mavilein Aug 04 '14 at 10:15
5

Yes, and that's exactly how forward is implemented: `def forward(message: Any)(implicit context: ActorContext) = tell(message, context.sender())` :-) Happy hakking! – Konrad 'ktoso' Malawski Aug 04 '14 at 10:16
1

Was also just having a look at the source. So easy to read up these things :-) – mavilein Aug 04 '14 at 10:17
For example : sender ! Message is it equal to sender tell Message or sender forward message – Jeff Lee Nov 25 '14 at 09:54
`!` (exclamation mark) is `tell`. forward does not have a symbolic method. – Konrad 'ktoso' Malawski Nov 25 '14 at 10:04

score 19 · Answer 2 · answered Aug 04 '14 at 09:35

19

Tell sets the sender as the actor sending the message.

Forward keeps the original sender of the message.

answered Aug 04 '14 at 09:35

sksamuel

16,154
8
60
108

2

plus 1 for keeping it simple – Sagar Feb 08 '18 at 05:49

score 1 · Answer 3 · answered Jul 28 '17 at 10:31

1

target.tell(message, getSelf()); final Object result = ""; target.forward(result, getContext());

Here, getself() is the self reference of the actor. getcontext() is the supervisor reference.

answered Jul 28 '17 at 10:31

Suresh Kumar

172
3
12

score 0 · Answer 4 · answered Sep 04 '17 at 07:18

import akka.actor.{Actor, ActorSystem, Props}
case object FromActor3
/**
  * forward method: Forwards the message and passes the original sender actor as the sender.
  */

object ActorForward extends App {

  class ActorExample extends Actor {
      def receive = {
       case message: String =>
        println(s"Message received from ${sender.path.name}, message = $message")
       val child = context.actorOf(Props[Actor2], "ChildActor")
       child ! message
      case FromActor3 => println("Response when forwarded by Actor2 to Actor3")
       }
  }

class Actor2 extends Actor {
    def receive = {
      case message: String =>
      println(s"Message received from ${sender.path.name}, message = $message")
    val child = context.actorOf(Props[Actor3], "ChildActor")
    println("forwarding...")
    child forward message
    case _ => println("Unknown message")
}
  }


class Actor3 extends Actor {
   def receive = {
    case message: String =>
    println(s"Message received from ${sender.path.name}, message = $message")
    sender ! FromActor3
   case _ => println("Unknown message")
}
  }


  val actorSystem = ActorSystem("ActorSystem")
  val actor = actorSystem.actorOf(Props[ActorExample], "RootActor")
  actor ! "Hello"
}

Difference between forward and tell in akka actors

4 Answers4