Akka中Actor消息通信的实现原理(源码解析)

最新推荐文章于 2025-05-05 16:36:51 发布

springlustre

最新推荐文章于 2025-05-05 16:36:51 发布

阅读量4.8k

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/springlustre/article/details/79082770

scala 专栏收录该内容

16 篇文章

订阅专栏

本文深入探讨了Akka框架中Actor模型的消息传递机制，包括如何通过tell和ask方式发送消息，以及消息是如何被封装并通过MailBox进行处理的过程。文章详细介绍了MailBox组件的功能及其内部工作原理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Akka中通过下面的方法向actor发送消息

! tell 意味着 “fire-and-forget”，即异步的发送消息无需等待返回结果
? ask 异步发送消息并返回代表可能回复的Future。

消息在每个发件人的基础上是有序的。

MailBox

Akka邮箱包含发往Actor的消息。通常每个Actor都有自己的邮箱，但是也有例外，比如BalancingPool所有路由将共享一个邮箱实例。

其中MessageQueue（akka.dispatch.MessageQueue）是形成Akka邮箱的心组件之一。
发送给Actor的普通消息将被排入队列（并随后出队列）它至少需要支持N个生产者和1个消费者的线程安全。它实现了入队列，出队列等方法

  def enqueue(receiver: ActorRef, handle: Envelope): Unit
  def dequeue(): Envelope
  def numberOfMessages: Int
  def hasMessages: Boolean
  def cleanUp(owner: ActorRef, deadLetters: MessageQueue): Unit

其中Envelope封装了message:Any和sender:ActorRef两个成员

final case class Envelope private (val message: Any, val sender: ActorRef)

SystemMessageQueue提供了systemEnqueue(入队列)和systemDrain(全部出队列)方法。MailBox继承自系统消息队列SystemMessageQueue和ForkJoinTask，实现了Runnable接口，同时包含ActorCell成员和MessageQueue成员

private[akka] abstract class Mailbox(val messageQueue: MessageQueue)
  extends ForkJoinTask[Unit] with SystemMessageQueue with Runnable {
  var actor: ActorCell = _
  }

其中ForkJoinTask是用少数线程执行海量独立任务的极好架构(独立任务指的是任务和任务之间不要有共享数据，否则会有并发访问的问题)
MailBox代理了MessageQueue的所有方法。MessageQueue的具体类型，根据MailBoxType的不同而不同。

tell 操作

在创建ActorSystem时，初始化默认的dispatcher，默认ForkJoinPool（ExecutorService）
在使用actorRef ! Message发送消息时，调用了actorCell对应的sendMessage方法，其中调用了dispatcher.dispatch方法

可以在ActorRef中可以看到

    def ! (message: Any)(implicit sender: ActorRef = Actor.noSender): Unit

在ActorCell.scala中

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

之后可以追踪到dungeon的Dispatch.scala文件

  def sendMessage(msg: Envelope): Unit =
    try {
      val msgToDispatch =
        if (system.settings.SerializeAllMessages) serializeAndDeserialize(msg)
        else msg

      dispatcher.dispatch(this, msgToDispatch)
    } catch handleException

而代码里的dispatcher.dispatch可以在dispatch.Dispatcher中找到：

     /**
      * INTERNAL API
      */
     protected[akka] def dispatch(receiver: ActorCell, invocation: Envelope): Unit = {
       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 = {
       if (mbox.canBeScheduledForExecution(hasMessageHint, hasSystemMessageHint)) { //This needs to be here to ensure thread safety and no races
         if (mbox.setAsScheduled()) {
           try {
             executorService execute mbox
             true
           } catch {
             case e: RejectedExecutionException ⇒
               try {
                 executorService execute mbox
                 true
               } catch { //Retry once
                 case e: RejectedExecutionException ⇒
                   mbox.setAsIdle()
                   eventStream.publish(Error(e, getClass.getName, getClass, "registerForExecution was rejected twice!"))
                   throw e
               }
           }
         } else false
       } else false
     }

dispatch方法做了两件事情：
一是将消息放到actorCell的消息队列中(maiBox 是 ActorCell 的成员变量)
二是调用dispather底层的线程池executor execute mbox执行mbox.run()(mailBox继承了
Runnable 接口所以能放入ExecutorService 中执行),

  override final def run(): Unit = {
    try {
      if (!isClosed) { //Volatile read, needed here
        processAllSystemMessages() //First, deal with any system messages
        processMailbox() //Then deal with messages
      }
    } finally {
      setAsIdle() //Volatile write, needed here
      dispatcher.registerForExecution(this, false, false)
    }
  }

  /**
     * Process the messages in the mailbox
     */
    @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) {
          if (Mailbox.debug) println(actor.self + " processing message " + next)
          actor invoke next
          if (Thread.interrupted())
            throw new InterruptedException("Interrupted while processing actor messages")
          processAllSystemMessages()
          if ((left > 1) && ((dispatcher.isThroughputDeadlineTimeDefined == false) || (System.nanoTime - deadlineNs) < 0))
            processMailbox(left - 1, deadlineNs)
        }
      }

执行mbox.run()中，先从SystemMessage链表中处理系统消息，
然后从MessageQueue成员中处理用户消息。
处理用户消息时，run 是一个递归函数，每次调用处理一个消息，
处理逻辑通过调用actorCell的invoke方法实现，根据dispatcher
的throughput决定处理多少条消息，
根据dispatcher的throughputDeadlineTime决定处理多长时间，
长度和时间在处理完一条消息后检查一次。

  final def invoke(messageHandle: Envelope): Unit = {
    val influenceReceiveTimeout = !messageHandle.message.isInstanceOf[NotInfluenceReceiveTimeout]
    try {
      currentMessage = messageHandle
      if (influenceReceiveTimeout)
        cancelReceiveTimeout()
      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 {
      if (influenceReceiveTimeout)
        checkReceiveTimeout // Reschedule receive timeout
    }
  }

 final def receiveMessage(msg: Any): Unit = actor.aroundReceive(behaviorStack.head, msg)

对 PoisonKill, Terminate 系统消息的处理在 autoReceiveMessage 中，
对普通消息的处理在 receiveMessage 中,

private var behaviorStack: List[Actor.Receive] = emptyBehaviorStack

可以看到behaviorStack 是一个 List[Actor.Receive]，

type Receive = PartialFunction[Any, Unit]

其中Receive (PartialFunction[Any, Unit])函数就是我们写的对 message 的处理逻辑。
因为 Actor 支持通过 become/unbecome 切换形态，
所以behaviorStack.head就是当前的Receive处理逻辑。

对于ForkJoinPool这种executor，每次执行execute(mbox)时，实
际上都是先创建一个继承自ForkJoinTask的MailboxExecutionTask，
其中的exec方法调用mbox.run方法，因此每次执行都会创建一个ForkJoinTask对象。

还有一点，消息队列都是放到actor对应的mailbox中（以Envelope的形式封装消息本身和sender），
而执行的task对象会放到Executor的每个线程对应的工作队列中，task和消息分别使用不同的队列。

参考
https://doc.akka.io/docs/akka/snapshot/mailboxes.html
https://doc.akka.io/docs/akka/snapshot/actors.html#send-messages
http://spartan1.iteye.com/blog/1641322