미래의 n 번 실행

Question

예를 들어 미래의 호출을 n 번 실행하고 싶습니다. 예를 들어, 미래의 "실행"에는 시간이 걸리고 이전이 완료되었을 때만 새로운 호출을하고 싶습니다. 예 :

def fun(times: Int): Future[AnyRef] = { 
    def _fun(times: Int) = { 
     createFuture() 
    } 

    (1 to times).foldLeft(_fun)((a,b) => { 
     println(s"Fun: $b of $times") 
     a.flatMap(_ => _fun) 
    }) 
} 

그래서 "_fun"함수를 하나씩 차례로 호출하고 싶습니다. "createFuture()"는 약간의 시간이 걸리므로, "_fun"은 이전에 미래가 완료되기 전에 다시 호출되어서는 안됩니다. 또한 비 차단 솔루션을 만들고 싶습니다. 현재이 코드는 이전의 미래를 기다리지 않고 실행됩니다.

아이디어를 얻는 방법에 대한 아이디어가 있으십니까?

답변 해 주셔서 감사합니다.

, 당신은 이런 식으로 뭔가를 시도해 볼 수도 있습니다 (난 그냥 마지막으로 완성 된 미래의 결과를 반환하는거야) 당신이 마지막 미래를 반환 할 정확히 이해하지 않고

Answer 1

:

def fun(times: Int): Future[AnyRef] = { 
    val prom = Promise[AnyRef]() 
    def _fun(t: Int) { 

    val fut = createFuture() 
    fut onComplete { 
     case Failure(ex) => prom.failure(ex) 
     case Success(result) if t >= times => prom.success(result) 
     case Success(result) => _fun(t + 1) 
    } 

    } 
    _fun(1) 

    prom.future 
} 

이것은 일종의 최대 횟수에 도달했을 때 연결을 중지하면서 완료시 미래를 함께 연결하는 재귀 솔루션 이 코드는 완벽하지는 않지만, 앞으로의 미래가 성공적으로 완료 될 때까지는 연속 미래를 확실히 보장 할 수있는 해결책을 제시합니다.

Answer 2

flatMap을 사용하여 재귀 적으로 만들면 더 멋지다고 생각합니다. 우리는 함수를 생성 할 수 있습니다

def createFuture() = Future(println("Create future")) 

가와 createFuture의 결과 구성하기 :

의 상상하자 당신은 당신의 createFuture는 다음과 같이 정의

def compose(f:() => Future[Unit])(b: Future[Unit]) = b.flatMap(_ => f()) 

을 그리고 당신은 같은 재미를 정의 할 수 있습니다

def fun(n : Int) = { 
    def nTimes(n : Int, f : Future[Unit] => Future[Unit], acc : Future[Unit]) = if (n == 0) acc else nTimes(n-1,f,f(acc)) 
    nTimes(n,compose(createFuture),Future()) 
}