Выполнение функции задержки

Каков самый простой способ отсрочить выполнение функции в Scala, что-то вроде JavaScript setTimeout? В идеале без нерестового потока за просроченное выполнение, т.е. Последовательное выполнение. Самое близкое, что я смог найти, это Akka Scheduler, но это перебор.

Для моих целей тестирования я открываю тысячи подключений, после чего они получают ответы через 10 секунд. В node.js это выглядит так:

http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  setTimeout(function() {res.end('Hello World\n');}, 10000 );
}).listen(8080, '127.0.0.1');

Но какая ближайшая версия Scala делает то же самое? Мне все равно, если res.end будет выполняться в нескольких потоках или поставлен в очередь в одном.

ОТВЕТЫ

Ответ 1

Устали от того, чтобы получить флак для ответа на вопрос простейшим слишком просто, вот стандартные идиомы JVM:

$ scala
Welcome to Scala 2.11.8 (Java HotSpot(TM) 64-Bit Server VM, Java 1.6.0_65).
Type in expressions for evaluation. Or try :help.

scala> import java.util.{Timer,TimerTask}
import java.util.{Timer, TimerTask}

scala> val timer = new Timer
timer: java.util.Timer = [email protected]

scala> def delay(f: () => Unit, n: Long) = timer.schedule(new TimerTask() { def run = f() }, n)
delay: (f: () => Unit, n: Long)Unit

scala> delay(() => println("Done"), 1000L)

scala> Done


scala> import java.util.concurrent._
import java.util.concurrent._

scala> val x = Executors.newScheduledThreadPool(2)
x: java.util.concurrent.ScheduledExecutorService = [email protected]

scala> x.schedule(new Callable[Int]() { def call = { println("Ran"); 42 }}, 1L, TimeUnit.SECONDS)
res3: java.util.concurrent.ScheduledFuture[Int] = java.[email protected]3ab0f534

scala> Ran

Нет API для планирования задачи с задержкой в ​​стандартной библиотеке, но вы можете сделать ExecutionContext с фиксированной задержкой, чтобы использовать Scala Future.

scala> import scala.concurrent._
import scala.concurrent._

scala> implicit val xx = new ExecutionContext() {
     | def reportFailure(t: Throwable) = t.printStackTrace()
     | def execute(r: Runnable) = x.schedule(new Callable[Unit]() { def call = r.run() }, 1L, TimeUnit.SECONDS)
     | }
xx: scala.concurrent.ExecutionContext = [email protected]

scala> Future(println("hello"))
res4: scala.concurrent.Future[Unit] = List()

scala> hello

scala> Future(42)
res5: scala.concurrent.Future[Int] = List()                

scala> .value
res6: Option[scala.util.Try[Int]] = Some(Success(42))

Или вы можете использовать планировщик Akka, который является каноническим ответом в Запланированном исполнителе в Scala

Старый однострочный:

Проще всего по-прежнему просто future { blocking(Thread.sleep(10000L)); "done" }

но я хотел разместить объявление для этого парня, с которым я только что столкнулся, что дает вам индикатор прогресса или промежуточное значение. Я вроде бы хотел, чтобы у него было другое имя, это все.

scala> import concurrent._
import concurrent._

scala> import ExecutionContext.Implicits._
import ExecutionContext.Implicits._

scala> import duration._
import duration._

scala> val deadline = 60.seconds.fromNow
deadline: scala.concurrent.duration.Deadline = Deadline(38794983852399 nanoseconds)

scala> new DelayedLazyVal(() => deadline.timeLeft.max(Duration.Zero), blocking {
     | Thread.sleep(deadline.timeLeft.toMillis)
     | Console println "Working!"
     | })
res9: scala.concurrent.DelayedLazyVal[scala.concurrent.duration.FiniteDuration] = [email protected]

scala> res9()
res10: scala.concurrent.duration.FiniteDuration = 23137149130 nanoseconds

scala> res9.isDone
res11: Boolean = false

scala> res9()
res12: scala.concurrent.duration.FiniteDuration = 12499910694 nanoseconds

scala> res9()
res13: scala.concurrent.duration.FiniteDuration = 5232807506 nanoseconds

scala> Working!


scala> res9.isDone
res14: Boolean = true

scala> res9()
res15: scala.concurrent.duration.FiniteDuration = 0 days

Здесь альтернативная формулировка с Либо, чтобы вычислить значение после задержки. Использование Left, конечно, когда еще есть время Left.

scala> new DelayedLazyVal(()=> if (deadline.hasTimeLeft) Left(deadline.timeLeft) else
     | Right("Working!"), blocking(Thread.sleep(deadline.timeLeft.toMillis)))
res21: scala.concurrent.DelayedLazyVal[Product with Serializable with scala.util.Either[scala.concurrent.duration.FiniteDuration,String]] = [email protected]

scala> res21()
res22: Product with Serializable with scala.util.Either[scala.concurrent.duration.FiniteDuration,String] = Left(28553649064 nanoseconds)

scala> res21()
res23: Product with Serializable with scala.util.Either[scala.concurrent.duration.FiniteDuration,String] = Left(9378334087 nanoseconds)

scala> res21.isDone
res24: Boolean = false

scala> res21()
res25: Product with Serializable with scala.util.Either[scala.concurrent.duration.FiniteDuration,String] = Right(Working!)

scala> res21.isDone
res26: Boolean = true