Scala Akka Actor中Await.result始终挂起/超时无返回的修复方案

你的代码超时的核心原因是在Actor的receive方法内部阻塞调用Await.result(self ? (x-1))：Actor是单线程串行处理消息的，当你向自身发送x-1的请求时，这条消息会被放入当前Actor的消息队列末尾，但当前的receive逻辑正阻塞等待该消息的回复，形成死锁，最终触发超时。

最简单的修复方案（非阻塞异步模式） #

将自身递归计算的逻辑从Actor消息调用改为内部方法直接处理，仅用子Actor处理x-2的分支，全程采用Akka异步模式避免阻塞：

import akka.actor.{Actor, PoisonPill, Props}
import akka.pattern.{ask, pipe}
import akka.util.Timeout
import scala.concurrent.duration._
import scala.concurrent.ExecutionContext.Implicits.global

class FibMachine extends Actor {
    implicit val timeout: Timeout = Timeout(5L, SECONDS)
    
    // 内部方法处理斐波那契递归，避免向自身发送消息
    private def fib(n: Int): Int = n match {
        case 0 => 0
        case 1 => 0 // 注：若遵循标准斐波那契定义，此处应改为1
        case x if x > 1 => fib(x-1) + fib(x-2)
    }
    
    override def receive: Receive = {
        case 0 => sender ! 0
        case 1 => sender ! 0
        case x: Int if x > 1 => {
            val child = context.actorOf(Props(new FibMachine()))
            // 异步请求子Actor计算x-2，合并本地计算的x-1结果后返回给发送者
            (child ? (x - 2)).mapTo[Int].map(_ + fib(x-1)).pipeTo(sender)
            child ! PoisonPill
        }
    }
}

另一种方案（全Actor异步递归） #

如果坚持用Actor处理所有递归分支，可改为创建两个子Actor分别处理x-1和x-2，避免向自身发送消息：

import akka.actor.{Actor, PoisonPill, Props}
import akka.pattern.{ask, pipe}
import akka.util.Timeout
import scala.concurrent.duration._
import scala.concurrent.ExecutionContext.Implicits.global

class FibMachine extends Actor {
    implicit val timeout: Timeout = Timeout(5L, SECONDS)
    
    override def receive: Receive = {
        case 0 => sender ! 0
        case 1 => sender ! 0
        case x: Int if x > 1 => {
            val child1 = context.actorOf(Props(new FibMachine()))
            val child2 = context.actorOf(Props(new FibMachine()))
            
            // 异步合并两个子Actor的计算结果，返回给发送者
            val resultFuture = for {
                num1 <- (child1 ? (x-1)).mapTo[Int]
                num2 <- (child2 ? (x-2)).mapTo[Int]
            } yield num1 + num2
            
            resultFuture.pipeTo(sender)
            
            child1 ! PoisonPill
            child2 ! PoisonPill
        }
    }
}

关键修改点 #

1. 移除Await.result的阻塞调用，改用Akka的ask+map+pipeTo异步模式，符合Actor模型的非阻塞设计原则
2. 避免向Actor自身发送消息，消除死锁根源
3. 用内部方法或子Actor分离递归计算逻辑，保证消息处理线程不被阻塞

内容的提问来源于stack exchange，提问作者user23764200