在Actor的receive方法中调用Multiple Future

Question

我正在尝试在Actor的receive方法中进行两次外部调用（到Redis数据库）。 两个调用返回Future ，我需要第一的结果Future第二内侧。 我将两个调用包装在一个Redis事务中，以避免其他人在我阅读时修改数据库中的值。

actor的内部状态根据第二个Future的值进行更新。

这是我当前的代码看起来像我不正确，因为我正在更新Future.onComplete回调中的actor的内部状态。

我不能使用PipeTo模式，因为我需要两个Future都必须在一个事务中。 如果我使用Await作为第一个Future那么我的receive方法将被阻止 。 知道如何解决这个问题吗？

我的第二个问题与我如何使用Future s有关。 Future的这种用法是否正确？ 是否有更好的方式来处理多个期货？ 想象一下，如果每个都有3个或4个Future，具体取决于前一个。

import akka.actor.{Props, ActorLogging, Actor}
import akka.util.ByteString
import redis.RedisClient

import scala.concurrent.Future
import scala.util.{Failure, Success}


object GetSubscriptionsDemo extends App {
  val akkaSystem = akka.actor.ActorSystem("redis-demo")
  val actor = akkaSystem.actorOf(Props(new SimpleRedisActor("localhost", "dummyzset")), name = "simpleactor")
  actor ! UpdateState
}

case object UpdateState

class SimpleRedisActor(ip: String, key: String) extends Actor with ActorLogging {

  //mutable state that is updated on a periodic basis
  var mutableState: Set[String] = Set.empty

  //required by Future
  implicit val ctx = context dispatcher

  var rClient = RedisClient(ip)(context.system)

  def receive = {
    case UpdateState => {
      log.info("Start of UpdateState ...")

      val tran = rClient.transaction()

      val zf: Future[Long] = tran.zcard(key)  //FIRST Future 
      zf.onComplete {

        case Success(z) => {
          //SECOND Future, depends on result of FIRST Future 
          val rf: Future[Seq[ByteString]] = tran.zrange(key, z - 1, z) 
          rf.onComplete {
            case Success(x) => {
              //convert ByteString to UTF8 String
              val v = x.map(_.utf8String)
              log.info(s"Updating state with $v ")
              //update actor's internal state inside callback for a Future
              //IS THIS CORRECT ?
              mutableState ++ v
            }
            case Failure(e) => {
              log.warning("ZRANGE future failed ...", e)
            }
          }
        }
        case Failure(f) => log.warning("ZCARD future failed ...", f)
      }
      tran.exec()

    }
  }

}

编译但是当我运行它时会被击中。

2014-08-07  INFO [redis-demo-akka.actor.default-dispatcher-3] a.e.s.Slf4jLogger - Slf4jLogger started
2014-08-07 04:38:35.106UTC INFO [redis-demo-akka.actor.default-dispatcher-3] e.c.s.e.a.g.SimpleRedisActor - Start of UpdateState ...
2014-08-07 04:38:35.134UTC INFO [redis-demo-akka.actor.default-dispatcher-8] r.a.RedisClientActor - Connect to localhost/127.0.0.1:6379
2014-08-07 04:38:35.172UTC INFO [redis-demo-akka.actor.default-dispatcher-4] r.a.RedisClientActor - Connected to localhost/127.0.0.1:6379

更新1

为了使用pipeTo模式，我需要访问我在管道Future的actor中的tran和FIRST Future（ zf ），因为SECOND Future取决于FIRST的值（ z ）。

    //SECOND Future, depends on result of FIRST Future 
      val rf: Future[Seq[ByteString]] = tran.zrange(key, z - 1, z) 

Answer 1

在不太了解您正在使用的redis客户端的情况下，我可以提供一个更干净的备用解决方案，并且不会出现关闭可变状态的问题。 这个想法是使用主/工作类情况，其中主（SimpleRedisActor）接收执行工作的请求，然后委托给执行工作的工作者并响应状态进行更新。 该解决方案看起来像这样：

object SimpleRedisActor{
  case object UpdateState
  def props(ip:String, key:String) = Props(classOf[SimpleRedisActor], ip, key)
}

class SimpleRedisActor(ip: String, key: String) extends Actor with ActorLogging {
  import SimpleRedisActor._
  import SimpleRedisWorker._

  //mutable state that is updated on a periodic basis
  var mutableState: Set[String] = Set.empty

  val rClient = RedisClient(ip)(context.system)

  def receive = {
    case UpdateState => 
      log.info("Start of UpdateState ...")      
      val worker = context.actorOf(SimpleRedisWorker.props)
      worker ! DoWork(rClient, key)

    case WorkResult(result) =>
      mutableState ++ result

    case FailedWorkResult(ex) =>
      log.error("Worker got failed work result", ex)
  }
}

object SimpleRedisWorker{
  case class DoWork(client:RedisClient, key:String)
  case class WorkResult(result:Seq[String])
  case class FailedWorkResult(ex:Throwable)
  def props = Props[SimpleRedisWorker]
}

class SimpleRedisWorker extends Actor{
  import SimpleRedisWorker._
  import akka.pattern.pipe
  import context._

  def receive = {
    case DoWork(client, key) =>
      val trans = client.transaction()
      trans.zcard(key) pipeTo self
      become(waitingForZCard(sender, trans, key) orElse failureHandler(sender, trans))
  }

  def waitingForZCard(orig:ActorRef, trans:RedisTransaction, key:String):Receive = {      
    case l:Long =>
      trans.zrange(key, l -1, l) pipeTo self
      become(waitingForZRange(orig, trans) orElse failureHandler(orig, trans))
  }

  def waitingForZRange(orig:ActorRef, trans:RedisTransaction):Receive = {
    case s:Seq[ByteString] =>
      orig ! WorkResult(s.map(_.utf8String))
      finishAndStop(trans)
  }

  def failureHandler(orig:ActorRef, trans:RedisTransaction):Receive = {
    case Status.Failure(ex) => 
      orig ! FailedWorkResult(ex)
      finishAndStop(trans)   
  }

  def finishAndStop(trans:RedisTransaction) {
    trans.exec()
    context stop self
  }
}

工作人员启动事务，然后调用redis并最终在停止之前完成事务。 当它调用redis时，它会获得未来并管道返回自身以继续处理，将接收方法改变为显示其状态进展的机制。 在这样的模型中（我认为它与错误核心模式有些相似），主人拥有并保护国家，将“有风险”的工作委托给能够弄清楚状态变化应该是什么的孩子，但变化仍归主人所有。

现在再一次，我不知道你正在使用的redis客户端的功能，以及它是否足够安全甚至可以做这种事情，但这不是重点。 关键在于展示一种更安全的结构，这种结构涉及需要安全更改的期货和状态。

Answer 2

使用回调来改变内部状态不是一个好主意，摘自akka docs ：

在使用未来的回调时，例如onComplete，onSuccess和onFailure，你需要小心避免关闭包含actor的引用，即不要在回调中调用方法或访问封闭actor上的可变状态。

你为什么担心pipeTo和交易？ 不确定redis事务是如何工作的，但我猜这个事务并不包含第二个未来的onComplete回调。

我会把状态变成一个单独的演员，你也管道未来。 这样，您就有了一个单独的邮箱，其中的顺序与修改状态所引入的邮件的顺序相同。 此外，如果有任何读取请求进入，它们也将按正确的顺序排列。

编辑以回复已编辑的问题：好的，所以你不想管道第一个未来，这是有道理的，并且应该没有问题，因为第一个回调是无害的。 第二个未来的回调就是问题，因为它操纵了国家。 但是这个未来可以管道而不需要访问交易。

基本上我的建议是：

val firstFuture = tran.zcard
firstFuture.onComplete {
   val secondFuture = tran.zrange
   secondFuture pipeTo stateActor
}

stateActor包含可变状态。