他の将来の未来を完了

Question

私はそれを上書きすることができる外部の将来の操作を持っています。私はそれを包み込み、プロミスの閉鎖によって完成させたいと思う。しかし私は他の未来の中でその未来を完了できませんでした。例えば：

import scala.concurrent.{Future, Promise} 
import scala.util.{Failure, Success} 
import scala.concurrent.ExecutionContext.Implicits.global 
def foo():Future[String] = { 
    val p = Promise[String]() 
    channel.addListener(new ChannelFutureListener[IoReadFuture] { 
    override def operationComplete(future: IoReadFuture): Unit = { 
    p.success("hello")} 
    } 
    p.future 
} 

val x = foo() 
x: scala.concurrent.Future[String] = List() 
x.onComplete{ 
    case Success(msg) => println(s"$msg world") 
    case Failure(e) => println(e.getMessage) 
} 
res1: Unit =() 

はをブロックせずにことを行うための慣用的な方法は何ですか？

Answer 1

delayを入力とし、delayed futureを返す関数を作成しようとしていると思います。

これを行うには、AwaitとPromiseを使用して非スリープ状態で行うことができます。

上記のamyはまともな実装のようですが、実際はそうではありません。 Awaitは実際にスレッドをブロックします。悲しいことに、慣用的なScalaでは完全に非ブロック的な方法でdelayedFutueを取得するのは簡単な方法ではありません。

あなたは、素敵な非ブロックおよびJavaからタイマーユーティリティを使用して、非スリープ遅れ未来を得ることができます

import scala.concurrent.ExecutionContext.Implicits.global 
import scala.concurrent.{Future, Promise} 
import java.util.{Timer, TimerTask} 

// delay is number of seconds 
def getDelayedFutureOfStringValue(delay: Int, value: String): Future[String] = { 
    val promise = Promise[String]() 
    val timer = new Timer() 
    val timerTask = new TimerTask { 
    override def run(): Unit = promise.success(value) 
    } 
    timer.schedule(timerTask, delay * 1000) 
    promise.future 
} 

val niceHelloFuture = getDelayedFutureOfStringValue(2, "hello") 

そして場合には、あなたはすでにあなたと一緒に未来を持っていて、構成するためにそれを使用したいですそれは非常に簡単です。俳優スケジューラの

import scala.concurrent.ExecutionContext.Implicits.global 
import scala.concurrent.{Future, Promise} 
import scala.util.{Failure, Success} 

// I assume you IoReadFuture is either similar to Future or wraps the actual Future 

def foo(value: String):Future[String] = { 
    val p = Promise[String]() 
    channel.addListener(new ChannelFutureListener[IoReadFuture] { 
    override def operationComplete(ioFuture: IoReadFuture): Unit = { 
     ioFuture.future.onComplete(_ => p.success(value)) 
    } 
    } 
    p.future 
} 

Answer 2

scheduleOne

import scala.concurrent.duration._ 
import scala.concurrent.ExecutionContext 
import ExecutionContext.Implicits.global 

val p = Promise(doSomething()) 
val system = akka.actor.ActorSystem("system") 
system.scheduler.scheduleOne(deplay seconds)(p.future) 
val f = p.future 
f.flatMap { println(s"${_}") }