scala – 延迟功能执行

发布时间：2020-12-16 09:19:43 所属栏目：安全来源：网络整理

导读：在Scala中延迟函数执行的最简单的方法是什么,像JavaScript的setTimeout？理想情况下,每个延迟执行都不产生线程,即顺序执行.我最能找到的是Akka的 Scheduler,但这是一个过度的杀伤力. 为了我的测试目的,我打开了数千个连接,然后他们在10秒内得到响应.在node.j

在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 Worldn');},10000 );
}).listen(8080,'127.0.0.1');

但是最接近的Scala版本会怎么样呢？我不在乎res.end是要在多个线程中执行还是在单个队列中执行.

解决方法

厌倦了简单地回答这个问题,这里是标准的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 = java.util.Timer@2d9ffd6f

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 = java.util.concurrent.ScheduledThreadPoolExecutor@2c5d529e

scala> x.schedule(new Callable[Int]() { def call = { println("Ran"); 42 }},1L,TimeUnit.SECONDS)
res3: java.util.concurrent.ScheduledFuture[Int] = java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask@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() },TimeUnit.SECONDS)
     | }
xx: scala.concurrent.ExecutionContext = $anon$1@40d3ab8b

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的调度程序,这是Scheduled Executor in Scala的规范答案

老一线：

最简单的只是将来{blocking(Thread.sleep(10000L)); “完成”}

但我想为这个人刚刚遇到的一个广告,给你一个进步指标或中间价值.我希望它有一个不同的名字,是的.

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] = scala.concurrent.DelayedLazyVal@50b56ef3

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

这是一个替代公式,或者是在延迟后计算一个值.当左边使用的时候还有剩下的时间.

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]] = scala.concurrent.DelayedLazyVal@78f9c6f2

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

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!