Kontekst wykonawczy dla kontraktów terminowych w Aktorach

Question

Posiadam aktora, a przy niektórych komunikatach uruchamiam metodę zwracającą Future.

def receive: Receive = { 

    case SimpleMessge() => 
     val futData:Future[Int] = ... 
     futData.map { data => 
      ... 
     } 
} 

Czy można przekazać rzeczywisty kontekst, aby czekać na te dane? Lub Await jest najlepszy, co mogę zrobić, jeśli potrzebuję tych danych w SimpleMessage?

Answer 1

Jeśli naprawdę trzeba czekać na przyszłość, aby zakończyć przed przetworzeniem następną wiadomość, możesz spróbować czegoś takiego:

object SimpleMessageHandler{ 
    case class SimpleMessage() 
    case class FinishSimpleMessage(i:Int) 
} 

class SimpleMessageHandler extends Actor with Stash{ 
    import SimpleMessageHandler._ 
    import context._ 
    import akka.pattern.pipe 

    def receive = waitingForMessage 
    def waitingForMessage: Receive = { 

    case SimpleMessage() => 
     val futData:Future[Int] = ... 
     futData.map(FinishSimpleMessage(_)) pipeTo self 
     context.become(waitingToFinish(sender)) 
    } 

    def waitingToFinish(originalSender:ActorRef):Receive = { 
    case SimpleMessage() => stash() 

    case FinishSimpleMessage(i) => 
     //Do whatever you need to do to finish here 
     ... 
     unstashAll() 
     context.become(waitingForMessage) 

    case Status.Failure(ex) => 
     //log error here 
     unstashAll() 
     context.become(waitingForMessage)  
    } 
} 

W tym podejściu, możemy przetworzyć SimpleMessage a następnie włącz obsługę logiki ukryta wszystkie kolejne SimpleMessage s otrzymane, dopóki nie otrzymamy wyniku z przyszłości. Kiedy otrzymamy wynik, niepowodzenie lub nie, odetniemy wszystkie pozostałe, które otrzymaliśmy, czekając na przyszłość i udając się na naszą wesołą drogę.

Ten aktor po prostu przełącza się między dwoma stanami, co pozwala tylko w pełni przetworzyć jeden plik SimpleMessage na raz, bez konieczności blokowania przyszłości.