두 명의 배우가 완료해야하는 Akka/Scala 약속

Question

저는 Scala와 Akka를 사용하여 주식 시장 애플리케이션을 구축 중입니다. 시장은 구매자와 판매자 일치하고 트랜잭션 처리하기 위해 구매자와 (어떤 시점에서) 완료 될 필요가 판매자 모두에

Promise[Transaction] 

를 보냅니다.

문제 중 하나

1. 구매자가 충분한 자금을 가지고 있기 때문에 약속
2. 판매자가 충분한 주식을 보유하고, 실패에 완료 할 수 있다는 것입니다.

두 배우의 협조가 필요한 스칼라 약속을 어떻게 만들 수 있습니까?

Answer 1

가능하면 ask을 사용하지 않으려면 피해야합니다.

약속을 구매자와 판매자 배우에게 보내고, 해당 선물을 구성하고 약속이 이행되면 거래를 처리하는 방법은 다음과 같습니다. 당신은 구매자로부터 자금을 얻을 수 있기 때문에, 당신은 판매자로부터 주식을 얻을 수 있기 때문에, 또는 뭔가 transact에 잘못된 때문에 : 궁극적 인 결과는 여러 가지 이유로 실패 할 수 있다는

는

import scala.concurrent.{future, promise} 
import scala.concurrent.ExecutionContext.Implicits.global 

val fundsPromise = promise[Funds] 
val sharesPromise = promise[Shares] 

buyerActor ! GetFunds(amount, fundsPromise) 
sellerActor ! GetShares(numShares, stock, sharesPromise) 

val futureFunds = fundsPromise.future 
val futureShares = sharesPromise.future 

val purchase = 
    for { funds <- futureFunds; shares <- futureShares } 
    yield transact(funds, shares) 

purchase onComplete { 
    case Success(transactionResult) => 
    buyerActor ! PutShares(numShares) 
    sellerActor ! PutFunds(amount) 
    // tell somebody it worked 
    case Failure(t) => 
    futureFunds onSuccess { case _ => buyerActor ! PutFunds(amount) } 
    futureShares onSuccess { case _ => sellerActor ! PutShares(numShares) } 
    // tell somebody it failed because of t 
} 

참고. 그래서 실패 할 때 우리는 자금을 확인하고 미래를 나눠 가지고 있는지 확인하고 만약 그렇다면 우리가 취한 것을 돌려줍니다.

또한 선물로는 amount 및 numShares을 마감합니다. 즉, val이어야합니다. 만약 그들이 vars 였다면, future가 실제로 실행될 때 잘못된 값을 사용하게 될 수도 있습니다.

bsmk가 지적했듯이 여기서는 과 sellerActor이 위의 코드와 동일한 JVM에 있다고 가정합니다. 만약 그렇지 않다면, 당신은 지역 배우가 원격 배우의 말을 듣고 약속을 처리하게 할 수 있습니다; 더 좋은 방법이 있다면 의견에 알려주십시오.

Answer 2

당신은 다음과 같이 뭔가를 할 수 :

def querySellingActor(seller : ActorRef) : Future[Boolean] = ??? 
def queryBuyingActor(buyer : ActorRef) : Future[Boolean] = ??? 

// Calling these outside the for-comprehension 
// ensures that they are really parallel 
val f1 = querySellingActor(sellerActor) 
val f2 = queryBuyingActor(buyerActor) 

val niceResult = for{ 
    sellerCanSell <- f1 
    buyerCanBuy <- f2 
} yield { sellerCanSell && buyerCanBuy } 

niceResult

지금 미래 [부울]입니다 주위에 전달 될 수 있으며, 당신이 그것에 당신의 답신 전화를 설치할 수 있습니다.

이

Answer 3

내가 단명 배우 패턴을 사용, 당신은 당신이 정말로 필요한 경우에만 ask 패턴을 사용해야합니다 :

이

case object TransactionTimeout 
case class NewTransaction(buyer: ActorRef, seller: ActorRef) 

class TransactionHandlerActor extends Actor with ActorLogging { 

    var _scheduled: Cancellable = null 
    var resultReceiver = Actor.noSender 
    var hasBuyerAnswered = false 
    var hasSellerAnswered = false 

    def receive: Receive = { 
    case NewTransaction(buyer, seller) => 
     resultReceiver = sender() 
     buyer ! BuyRequest(...) 
     seller ! SellRequest(...) 
     _scheduled = context.system.scheduler.scheduleOnce(5 seconds)(self ! TransactionTimeout) 

    case TransactionTimeout => 
     resultReceiver ! TransactionError(...) 
     context.stop(self) 

    case BuyerResponse(...) => 
     hasBuyerAnswered = true 
     checkIfComplete() 
    case SellerResponse(...) => 
     hasSellerAnswered = true 
     checkIfComplete() 
    } 

    def checkIfComplete() = { 
    if(hasBuyerAnswered && hasSellerAnswered) { 
     /* finalize operation */ 
     resultReceiver ! TransactionCompleted(...) 
     _scheduled.cancel() 
     context.stop(self) 
    } 
    } 
} 

기본적으로 임시 배우가 트랜잭션을 처리하고 완료되면 자신을 중지, 제한 시간이있다 그가 응답을 영원히 기다리지 않을 것입니다. 이것은 당신이 할 수있는 것, 코드가 테스트되지 않은 것의 아주 간단한 예입니다.