[SCALA] 스칼라 선물에 의해 반환 된 액세스 값

스칼라 선물에 의해 반환 된 액세스 값

나는 스칼라 선물에 초보자 그리고 난 스칼라 선물의 반환 값에 대한 의심의 여지가있다.

스칼라의 미래이기 때문이다 그래서 일반적으로 구문

 def downloadPage(url: URL) = Future[List[Int]] {

 }

나는이 방법을 호출하는 다른 방법에서 목록 [지능]에 액세스하는 방법을 알고 싶어요.

다시 말해,

val result = downloadPage("localhost") 

다음 무슨 일이 미래에서 목록 [지능] 얻을 수있는 방법이 될 것인가?

나는이 successfully.`을 할 수지도 방법하지만를 사용하여 시도

해결법

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

   1.가장 좋은 방법은 당신이 값을 반환하지 않는다는 것입니다. 대신 당신은 미래 (또는 등지도, flatMap,로 형질 전환 된 버전)이 값을 필요로 모든 사람에게 전달하고 자신의 onComplete를 추가 할 수 있습니다.

   가장 좋은 방법은 당신이 값을 반환하지 않는다는 것입니다. 대신 당신은 미래 (또는 등지도, flatMap,로 형질 전환 된 버전)이 값을 필요로 모든 사람에게 전달하고 자신의 onComplete를 추가 할 수 있습니다.

   당신이 정말로 (예를 들어, 기존 방법을 구현할 때)을 반환해야하는 경우에, 당신이 할 수있는 유일한 방법은 (예를 들어, Await.result와) 블록에 그리고 당신은 얼마나 오래 기다리고 결정해야합니다.

2. ==============================

   2.당신은 미래의 어떤 시간 범위 주어진 결과를 얻을 완료 될 때까지 기다릴 필요가, 여기의 뭔가가 작동 것이다 :

   당신은 미래의 어떤 시간 범위 주어진 결과를 얻을 완료 될 때까지 기다릴 필요가, 여기의 뭔가가 작동 것이다 :

     import scala.concurrent.duration._
   
     def downloadPage(url: URL) = Future[List[Int]] {
       List(1,2,3)
     }
   
     val result = downloadPage("localhost")
   
     val myListInt = result.result(10 seconds)
   

   당신이 미래를 사용하는 경우 이상적으로, 당신은 당신이이처럼 onComplete를 방법으로 당신의 미래의 결과로 어떤 거래를 당신의 논리를 이동하는 것이 할 수 있도록, 실행중인 스레드를 차단하지 않으 :

     result.onComplete({
       case Success(listInt) => {
         //Do something with my list
       }
       case Failure(exception) => {
         //Do something with my error
       }
     })
   

3. ==============================

   3.그것은 2013 년에 물었다하지만 어쩌면 내 대답은 다른 사람을 도울 수 있기 때문에 나는 이미이 문제를 해결 희망 :

   그것은 2013 년에 물었다하지만 어쩌면 내 대답은 다른 사람을 도울 수 있기 때문에 나는 이미이 문제를 해결 희망 :

   당신이 플레이 프레임 워크를 사용하는 경우, 그것은 (실제로 모든 작업이 비동기 내부에) 비동기 작업을 지원합니다. 비동기 작업을 생성하는 쉬운 방법이 Action.async을 사용하고 있습니다 (). 이 기능에 대한 미래 [결과]을 제공해야합니다.

   지금 당신은 당신의 미래에서 변환을 할 수 있습니다 [목록 [지능] 미래 스칼라의지도를 이용하여 [결과]로, flatMap에 대한-이해 또는 비동기 / 기다리고 있습니다. 플레이 프레임 워크 문서에서 예를 들어 여기에.

   import play.api.libs.concurrent.Execution.Implicits.defaultContext
   
   def index = Action.async {
     val futureInt = scala.concurrent.Future { intensiveComputation() }
     futureInt.map(i => Ok("Got result: " + i))
   }
   

4. ==============================

   4.당신은 그런 일을 할 수 있습니다. 그것을 실행하기 awaitable 걸리는 시간보다 Await.result 방법에 제시되어 대기 시간이 적은 경우, 당신은 TimeoutException을해야합니다, 당신은 오류 (또는 다른 오류를) 처리 할 필요가있다.

   당신은 그런 일을 할 수 있습니다. 그것을 실행하기 awaitable 걸리는 시간보다 Await.result 방법에 제시되어 대기 시간이 적은 경우, 당신은 TimeoutException을해야합니다, 당신은 오류 (또는 다른 오류를) 처리 할 필요가있다.

   import scala.concurrent._
   import ExecutionContext.Implicits.global
   import scala.util.{Try, Success, Failure}
   import scala.concurrent.duration._
   
   object MyObject {
       def main(args: Array[String]) {
   
           val myVal: Future[String] = Future { silly() }
   
           // values less than 5 seconds will go to 
           // Failure case, because silly() will not be done yet
           Try(Await.result(myVal, 10 seconds)) match {
               case Success(extractedVal) => { println("Success Happened: " + extractedVal) }
               case Failure(_) => { println("Failure Happened") }
               case _ => { println("Very Strange") }
           }      
       }
   
       def silly(): String = {
           Thread.sleep(5000)
           "Hello from silly"
           }
   }
   

5. ==============================

   5.나는 미래를 생각하는 것으로 나타났습니다 가장 좋은 방법은 의지, 어떤 점에서, 당신이 원하는 일을 포함하는 박스입니다. Future를 가진 중요한 건 당신이 상자를 열지 못할 것입니다. 상자를 열고 강제하려는 시도는 차단과 슬픔에 당신을 이끌 것입니다. 대신, 당신은 일반적으로지도 방법을 사용하여, 또 다른, 더 큰 상자에 미래를 넣어.

   나는 미래를 생각하는 것으로 나타났습니다 가장 좋은 방법은 의지, 어떤 점에서, 당신이 원하는 일을 포함하는 박스입니다. Future를 가진 중요한 건 당신이 상자를 열지 못할 것입니다. 상자를 열고 강제하려는 시도는 차단과 슬픔에 당신을 이끌 것입니다. 대신, 당신은 일반적으로지도 방법을 사용하여, 또 다른, 더 큰 상자에 미래를 넣어.

   다음은 문자열을 포함하는 미래의 예입니다. 미래의 완료는 다음 Console.println가 호출 될 때 :

   import scala.concurrent.Future
   import scala.concurrent.ExecutionContext.Implicits.global
   
   object Main {
   
     def main(args:Array[String]) : Unit = {
       val stringFuture: Future[String] = Future.successful("hello world!")
       stringFuture.map {
         someString =>
           // if you use .foreach you avoid creating an extra Future, but we are proving
           // the concept here...
           Console.println(someString)
       }
     }
   }
   

   이 경우, 우리는 마무리 ... 다음 main 메소드를 호출하고 있습니다. 글로벌 ExecutionContext에 제공하는 문자열의 미래, Console.println를 호출하는 작업을 수행합니다. 우리가 someString가 될 것입니다 때 통제를 포기 때 Console.println를 호출 할 것입니다 때, 우리는 시스템 자체를 관리 할 수 ​​있기 때문에, 중대하다. 우리는 열려있는 상자를 강제하려고 할 때 constrast에서 보면 무슨 일 :

   val stringFuture: Future[String] = Future.successful("hello world!")
   val someString = Future.await(stringFuture)
   

   그 엄지 손가락을 만지작 스레드를 유지 - - 우리가 someString 뒤로를 얻을 때까지이 경우, 우리는 기다려야한다. 우리는 상자를 열었습니다, 그러나 우리는 그것을 얻기 위해 시스템의 자원을 징집 했어.

from https://stackoverflow.com/questions/17713642/accessing-value-returned-by-scala-futures by cc-by-sa and MIT license