tell (!)

final def tell(msg: Any, sender: ActorRef): Unit = this.!(msg)(sender)

tell 函数是 actor 的核心，actor 是事件 (message) 驱动的，对 message 的处理逻辑都定义在 receive 函数中，只有当 message 到来时这些逻辑才会被调用。

// 用法
val actor = system.actorOf(Props[PingActor], "ping-actor")
actor ! "regards"

如果用 Intellij 查看 ! 函数的实现，IDE 会跳转到 ScalaActorRef

// If invoked from within an actor, then the actor reference is implicitly passed on as the implicit 'sender' argument
trait ScalaActorRef { ref: ActorRef =>
    def !(message: Any)(implicit sender: ActorRef = Actor.noSender): Unit
}

在一个 scala trait 中看到 ref: ActorRef => 的写法，就意味着该 trait 的实现类必须也要继承 ActorRef，这算是一个依赖声明吧。

在 IDE 的帮助下，只能看到这一步了，找不到 ! 的具体实现。 intellij 对 scala 的支持还是不够 intelligent。其实 ! 函数最终会走到 Cell 的 sendMessage 方法上：

final def sendMessage(message: Any, sender: ActorRef): Unit =
    sendMessage(Envelope(message, sender, system))

然而，IDE 还是找不到 Cell.sendMessage 的具体实现

ActorCell extends Cell With dungeon.Dispatcher

sendMessage 的具体在 dungeon.Dispatcher

private[akka] trait Dispatch { this: ActorCell ⇒
  def sendMessage(msg: Envelope): Unit =
    try {
      dispatcher.dispatch(this, msg)
    } catch handleException

上面提到过 ref: ActorRef => 的用法，这里又碰到了，this: ActorCell => 道理一样，不过这边依赖的意图更加明显了。IDE 找不到 sendMessage 的实现也属正常，Scala 的继承关系太乱，是不好找。相比较而言 Java 就简单的多，Java 虽然支持 interface 的多重继承，但是这些 interface 仅提供函数声明，不提供函数实现，IDE 找函数的实现只会在一条继承链上。而 scala 对应的 trait 则不然，它能提供函数声明和实现，这样 IDE 找函数的实现就麻烦的多，一个类继承的 trait 中都可能有，当然也不是做不到，就看 IDE team 是不是愿意做了。

dispatcher 函数的定义在 MessageDispatcher 中，实现在子类 Dispatcher 中

protected[akka] def dispatch(receiver: ActorCell, invocation: Envelope): 
    val mbox = receiver.mailbox
    mbox.enqueue(receiver.self, invocation)
    registerForExecution(mbox, true, false)
}
  
protected[akka] override def registerForExecution(mbox: Mailbox, hasMessageHint: Boolean, hasSystemMessageHint: Boolean): Boolean = {
    executorService execute mbox

private[akka] abstract class Mailbox(val messageQueue: MessageQueue)
  extends SystemMessageQueue with Runnable

maiBox 是 ActorCell 的成员变量（通过继承 Dispatcher 得来），它继承 Runnable 接口所以能放入 ExecutorService 中执行。我们说 actor ! Message 对消息的处理是异步的，其实直到 excutorService 之前，上面的所有逻辑还都发生在 sender 线程里，从这一行代码开始，sender 线程可以腾出手做下面的事了。这个 executorService 是配在 receiver 中的，和 sender 所在的线程池也没关系。

final def run = {
    processAllSystemMessages() //First, deal with any system messages
    processMailbox() //Then deal with messages
    
@tailrec private final def processMailbox(
    left: Int = java.lang.Math.max(dispatcher.throughput, 1),
    deadlineNs: Long = if (dispatcher.isThroughputDeadlineTimeDefined == true) System.nanoTime + dispatcher.throughputDeadlineTime.toNanos else 0L): Unit =
    if (shouldProcessMessage) {
      val next = dequeue()
      if (next ne null) {
        actor invoke next
        processAllSystemMessages()
        if ((left > 1) && ((dispatcher.isThroughputDeadlineTimeDefined == false) || (System.nanoTime - deadlineNs) < 0))
          processMailbox(left - 1, deadlineNs)
      }
    }    

MailBox 继承了 Runnable 接口，自然有 run 函数。run 是一个递归函数，每次调用处理一个消息，处理逻辑通过调用 invoke 函数实现

final def invoke(messageHandle: Envelope): Unit = try {
    currentMessage = messageHandle

    messageHandle.message match {
      case msg: AutoReceivedMessage ⇒ autoReceiveMessage(messageHandle)
      case msg                      ⇒ receiveMessage(msg)
    }
    currentMessage = null // reset current message after successful invocation
  } catch handleNonFatalOrInterruptedException { e ⇒
    handleInvokeFailure(Nil, e)
  } finally {
    checkReceiveTimeout // Reschedule receive timeout
  }
  
final def receiveMessage(msg: Any): Unit = actor.aroundReceive(behaviorStack.head, msg)  
  

对 PoisonKill, Terminate 系统消息的处理在 autoReceiveMessage 中，对普通消息的处理在 receiveMessage 中, behaviorStack 是一个 List[Actor.Receive]，因为 Actor 支持通过 become/unbecome 切换形态。而 Receive (PartialFunction[Any, Unit])函数就是我们写的对 message 的处理逻辑。

ask (?)

actor 本身是没有 ask 函数的，如果想用 ask 函数，需要引入 akka.pattern.ask 依赖。Akka 官方并不推荐使用 ask 函数，因为它意味着处理 message 的 actor (receiver) 需要把处理结果返回 sender，这就引入了 sender 和 receiver 之间的依赖关系，本来 actor 之间都是各个独立存在的实体，因为 ask 函数引入了依赖会使程序变得复杂。但是在某些场景下 ask 函数会带来极大的便利性，所以它的存在还是有必要的。最终 akka 对 ask 的设计就像我们看到的一样，没有把 ask 作为 actor 的成员函数，表明自己对 ask 的不推荐态度，但又以隐式转换的方式支持它，表示如果你真的要用，我们仍提供这种 capability。

class PingActor extends Actor {
  override def receive: Receive = {
    case num: Int => sender() ! num+1
    case msg => println(msg)
    }
}

class testing extends FunSuite {

  val system = ActorSystem("testing")
  implicit val timeout = Timeout(3 second)
  import scala.concurrent.ExecutionContext.Implicits.global

  test("send arbitrary message to ping actor") {
    val pingActor = system.actorOf(Props[PingActor], "pingActor")

    pingActor ? "msg" onComplete {
      case Success(res) => println("ask success")
      case Failure(exp) => println("ask failure") // return failure
    }
    Thread.sleep(5000)
  }

  test("send num to ping actor") {
    val pingActor = system.actorOf(Props[PingActor], "pingActor")
    pingActor ? 1 onComplete {
      case Success(res) => println("ask success") // return success
      case Failure(exp) => println("ask failure")
    }
    Thread.sleep(5000)
  }
}

上面的例子展示了 ask (?) 函数的用法，两个相似的请求却有着不同的结果，写代码时要注意 ask message 时，这个 message 会返回结果。

那么 ask 函数是怎么实现的呢？简单来讲，就是创建了一个 proxy actor (PromiseActorRef)，它负责接受 receiver 处理后的返回值（假如 receiver 处理完消息后会返回给 sender 结果），proxy actor 拿到返回值后填充 Promise 变量，使 promise.future 可用。

// 只保留重要代码
actorRef ? Message

//implicit conversion
implicit def ask(actorRef: ActorRef): AskableActorRef = new AskableActorRef(actorRef)

AskableActorRef(val actorRef: ActorRef) extends AnyVal
    def ask(message: Any)(implicit timeout): Future[Any] = 
        val a = PromiseActorRef(actorRef.provider, timeout)
        // 对 Promise 的调用在这里
        actorRef.tell(message, a)
        a.result.future

通过隐式转换把 ActorRef 类型转换成 AskableActorRef，其实它并不是 ActorRef 的子类，只是一个转换器而已。在 ask 函数创建 PromiseActorRef 并返回它的 promise.future，这是 promise 的典型用法，返回一个 “契约”。注意创建 PromiseActorRef 是通过 companion object。

PromiseActorRef
    def apply(provider: ActorRefProvider, timeout): PromiseActorRef
        result = Promise[Any]
        a = new PromiseActorRef(provider, result)
        implicit val ec = a.internalCallingThreadExecutionContext
        f = scheduler.scheduleOnce(timeout.duration)
            result tryComplete Failure(new AskTimeoutException()
        result.future onComplete { a.stop finally f.cancel)
        a

PromiseActorRef(provider: ActorRefProvider, result: Promise[Any])
    override def !(message)(implicit sender: ActorRef) = 
        message match
            case Status.Success(r) => result.success(r)
            case Status.failure(r) => result.failure(r)
            case other => Success(other) // this one is what we got

ask 函数就是 ?, tell 函数就是 !. companion 在创建 PromiseActorRef 后启动定时器，超时后定时器会返回 Failure. PromiseActorRef 的 sender 函数很简单，就是填充 promise，填充完毕后 AskActorRef.ask 函数的返回值就有效了。注意，Status.Success 和 Status.failure 一般情况下应该用不着，大部分情况会走到 other 分支。

根据这个逻辑再回看最上面的 PingActor, 它在收到 num: Int 类型的数据后执行 sender() ! num+1，其实这个 sender() 就是 PromiseActorRef，这样逻辑就走通了。