Scala - ScheduledFuture

Question

私は将来の予定をScalaで実装しようとしています。私は特定の時間を待ってから体を実行したいと思います。これまでのところ、私は次の単純なアプローチを試した。

val d = 5.seconds.fromNow 

val f = future {Await.ready(Promise().future, d.timeLeft); 1} 

val res = Await.result(f, Duration.Inf) 

私は将来TimeoutExcpetionを取得している。これは正しいアプローチですか、それとも単にJavaからScheduledExecutorを使うべきですか？

Answer 1

あなたはこのような何かにあなたのコードを変更することができます：

val d = 5.seconds.fromNow 
val f = Future {delay(d); 1} 
val res = Await.result(f, Duration.Inf) 

def delay(dur:Deadline) = { 
    Try(Await.ready(Promise().future, dur.timeLeft)) 
} 

しかし、私はそれをお勧めしません。そうすることで、あなたは未来をブロックすることになるでしょう。ブロックすることは決して完了しません。私はあなたが述べたようにJavaのスケジュールされたエグゼキュータを使って調べるか、Akkaを@ alex23として推奨することを検討することができます。

Answer 2

標準ライブラリだけを使用して、それをそのまま使用することは何もありません。 Javaの予定の先物とは異なり、この実装はさせないことを

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

DelayedFuture(5 seconds)(println("Hello")) 

注：これは、このように使用することができます

object DelayedFuture { 
    import java.util.{Timer, TimerTask} 
    import java.util.Date 
    import scala.concurrent._ 
    import scala.concurrent.duration.FiniteDuration 
    import scala.util.Try 

    private val timer = new Timer(true) 

    private def makeTask[T](body: => T)(schedule: TimerTask => Unit)(implicit ctx: ExecutionContext): Future[T] = { 
    val prom = Promise[T]() 
    schedule(
     new TimerTask{ 
     def run() { 
      // IMPORTANT: The timer task just starts the execution on the passed 
      // ExecutionContext and is thus almost instantaneous (making it 
      // practical to use a single Timer - hence a single background thread). 
      ctx.execute( 
      new Runnable { 
       def run() { 
       prom.complete(Try(body)) 
       } 
      } 
     ) 
     } 
     } 
    ) 
    prom.future 
    } 
    def apply[T](delay: Long)(body: => T)(implicit ctx: ExecutionContext): Future[T] = { 
    makeTask(body)(timer.schedule(_, delay)) 
    } 
    def apply[T](date: Date)(body: => T)(implicit ctx: ExecutionContext): Future[T] = { 
    makeTask(body)(timer.schedule(_, date)) 
    } 
    def apply[T](delay: FiniteDuration)(body: => T)(implicit ctx: ExecutionContext): Future[T] = { 
    makeTask(body)(timer.schedule(_, delay.toMillis)) 
    } 
} 

： 最も簡単なユースケースの場合、あなたはこのような小さなヘルパーを使用することができますあなたは未来をキャンセルします。

Answer 3

私のソリューションは、レジスのにかなり似ていますが、私はスケジュールにアッカを使用します。

def delayedFuture[T](delay: FiniteDuration)(block: => T)(implicit executor : ExecutionContext): Future[T] = { 
    val promise = Promise[T] 

    Akka.system.scheduler.scheduleOnce(delay) { 
     try { 
     val result = block 
     promise.complete(Success(result)) 
     } catch { 
     case t: Throwable => promise.failure(t) 
     } 
    } 
    promise.future 
    } 

Answer 4

アッカがakka.patternました：

def after[T](duration: FiniteDuration, using: Scheduler)(value: ⇒ Future[T])(implicit ec: ExecutionContext): Future[T] 

は「完成する予定scala.concurrent.Futureを返します。指定された期間の後に提供された値が成功したか失敗したかを示します。

このため

http://doc.akka.io/api/akka/2.2.1/#akka.pattern.package

Answer 5

最短ソリューション、おそらくスカラ・非同期を利用している：

import scala.async.Async.{async, await} 

def delay[T](value: T, t: duration): Future[T] = async { 
    Thread.sleep(t.toMillis) 
    value 
} 

やケースには、あなたがブロックの遅延実行をしたい

def delay[T](t: duration)(block: => T): Future[T] async { 
    Thread.sleep(t.toMillis) 
    block() 
} 

Answer 6

他のすべてソリューションはakkaを使用するか、遅延タスクごとにスレッドをブロックします。より良い解決策（既にakkaを使用している場合を除く）は、javaのScheduledThreadPoolExecutorを使用することです。ここではそのためのScalaラッパーの例です：

https://gist.github.com/platy/8f0e634c64d9fb54559c

Answer 7

あなたがアッカせずに完了のスケジュールを設定したい場合は、あなたが完了するために約束をスケジュールするために、通常のJavaタイマーを使用することができます。

def delay[T](delay: Long)(block: => T): Future[T] = { 
    val promise = Promise[T]() 
    val t = new Timer() 
    t.schedule(new TimerTask { 
    override def run(): Unit = { 
     promise.complete(Try(block)) 
    } 
    }, delay) 
    promise.future 
}