[SCALA] scala.concurrent.Promise의 사용 사례는 무엇입니까?

scala.concurrent.Promise의 사용 사례는 무엇입니까?

나는 SIP-14 읽고있다와 미래의 개념은 완벽한 이해하고 이해하기 쉽게 만든다. 그러나 약속에 대한 두 가지 질문이있다 :

읽기 쉬운하지만 우리는 정말 그런 쓰기에 필요합니까? 난 단지 미래에이 같은 약속없이 구현하기 위해 노력했다 :

val f = future {
   produceSomething()
}

val producer = future {
   continueDoingSomethingUnrelated()
}

startDoingSomething()

val consumer = future {
  f onSuccess {
    case r => doSomethingWithResult()
  }
}

어떤이의 차이 주어진 예는 어떤는 약속이 필요 하죠?

해결법

1. ==============================

   1.약속과 미래 보완적인 개념이다. 미래는 미래에 언젠가, 음, 검색됩니다 값이며, 해당 이벤트가 발생했을 때 당신은 그것으로 물건을 할 수 있습니다. 그것은 당신이에서 값을 검색하는 것을 무언가이다 - 따라서, 읽기 또는 계산 중 엔드 포인트입니다.

   약속과 미래 보완적인 개념이다. 미래는 미래에 언젠가, 음, 검색됩니다 값이며, 해당 이벤트가 발생했을 때 당신은 그것으로 물건을 할 수 있습니다. 그것은 당신이에서 값을 검색하는 것을 무언가이다 - 따라서, 읽기 또는 계산 중 엔드 포인트입니다.

   약속은 유사한 방법에 의해, 연산의 기입 측이다. 당신은 당신이 계산의 결과를두고 있습니다 장소입니다 약속을 만드는 것과 당신이 약속에 넣고 결과를 읽는 데 사용됩니다 미래를 얻을 약속드립니다. 당신이 실패 또는 성공 중 하나 약속을 완료 할 수 있습니다하면 관련 미래에 부착 된 모든 동작을 트리거합니다.

   첫 번째 질문에 대해서는,이 약속 p를 위해 그것을 할 수있는 방법을 우리는 p.future == 페이지가 있습니다. 처음에 비어있는 용기를 당신은 afterwords 영원히 그 내용이 될 것이다 하나 개의 값을 저장할 수 있습니다 - 당신은 단일 항목 버퍼처럼이 상상할 수있다. 지금, 당신의 관점에 따라이 약속과 미래 모두이다. 이 버퍼의 값을 작성하고자하는 사람에 대한 약속입니다. 이 값은 버퍼에 넣어하는 것을 기다립니다 누군가를위한 미래입니다.

   특히, 스칼라 동시 API를 들어, 당신이 약속 동반자 객체의 방법을 실시하는 방법을 볼 수 있습니다 여기에 약속의 특성에 대해 살펴 경우 :

   object Promise {
   
     /** Creates a promise object which can be completed with a value.
      *  
      *  @tparam T       the type of the value in the promise
      *  @return         the newly created `Promise` object
      */
     def apply[T](): Promise[T] = new impl.Promise.DefaultPromise[T]()
   
     /** Creates an already completed Promise with the specified exception.
      *  
      *  @tparam T       the type of the value in the promise
      *  @return         the newly created `Promise` object
      */
     def failed[T](exception: Throwable): Promise[T] = new impl.Promise.KeptPromise[T](Failure(exception))
   
     /** Creates an already completed Promise with the specified result.
      *  
      *  @tparam T       the type of the value in the promise
      *  @return         the newly created `Promise` object
      */
     def successful[T](result: T): Promise[T] = new impl.Promise.KeptPromise[T](Success(result))
   
   }
   

   이제 약속의 그 구현은 DefaultPromise 및 KeptPromise는 여기에서 찾을 수 있습니다. 둘 다 같은 이름을 가지고 어떻게 기본 약간의 특성을 확장 있지만 다른 패키지에 있습니다 :

   private[concurrent] trait Promise[T] extends scala.concurrent.Promise[T] with scala.concurrent.Future[T] {
     def future: this.type = this
   }
   

   그래서 당신은 그들이 p.future == 페이지가 무엇을 의미하는지 알 수 있습니다.

   KeptPromise가 매우 생성에서의 값으로 넣어 버퍼 동안 DefaultPromise는 I 위에서 언급 된 버퍼이다.

   귀하의 예에 대해서는, 당신이 사용하는 미래 블록은 실제로 보이지 않는 약속을 만듭니다. 여기에 미래의 정의에서 살펴 보자 :

   def future[T](body: =>T)(implicit execctx: ExecutionContext): Future[T] = Future[T](body)
   

   방법의 체인을 따라 당신은 impl.Future에서 생을 마감 :

   private[concurrent] object Future {
     class PromiseCompletingRunnable[T](body: => T) extends Runnable {
       val promise = new Promise.DefaultPromise[T]()
   
       override def run() = {
         promise complete {
           try Success(body) catch { case NonFatal(e) => Failure(e) }
         }
       }
     }
   
     def apply[T](body: =>T)(implicit executor: ExecutionContext): scala.concurrent.Future[T] = {
       val runnable = new PromiseCompletingRunnable(body)
       executor.execute(runnable)
       runnable.promise.future
     }
   }
   

   당신이 볼 수 그래서, 당신은 당신의 프로듀서 블록에서 얻는 결과는 약속에 주입됩니다.

   LATER 편집 :

   실제 사용에 대해서는 : 대부분의 시간을 당신이 직접 약속을 처리하지 않습니다. 당신은 라이브러리의 메소드에 의해 반환되는 미래에 당신이거야 그냥 작동 후 비동기 계산을 수행하는 라이브러리를 사용합니다합니다. 약속은,이 경우, 라이브러리에 의해 만들어집니다 - 당신은 단지 그 방법이 무엇의 읽기 끝으로 노력하고 있습니다.

   당신이 당신의 자신의 비동기 API를 구현해야한다면 당신은 그들과 함께 작업을 시작해야합니다. 당신의 상단에 비동기 HTTP 클라이언트를 구현해야한다고 가정 인 Netty 말할 수 있습니다. 그런 다음 코드는 다음과 다소 보일 것이다

       def makeHTTPCall(request: Request): Future[Response] = {
           val p = Promise[Response]
           registerOnCompleteCallback(buffer => {
               val response = makeResponse(buffer)
               p success response
           })
           p.future
       }
   

from https://stackoverflow.com/questions/13381134/what-are-the-use-cases-of-scala-concurrent-promise by cc-by-sa and MIT license