23

假设我有一个函数，它调用一个阻塞的可中断操作。我想在超时的情况下异步运行它。也就是说，我想在超时到期时中断该功能。

所以我正在尝试做这样的事情：

导入 scala.util.Try
导入 scala.concurrent.Future

def launch(f: () => Unit, timeout: Int): Future[Try[Unit]] = {

  val aref = new java.util.concurrent.atomic.AtomicReference[Thread]()

  导入 ExecutionContext.Implicits.global
  未来 {Thread.sleep(timeout); aref.get().interrupt} // 1
  未来 {aref.set(Thread.currentThread); 尝试（f（））} // 2
}

问题是arefin (1) 可以为 null，因为 (2) 尚未将其设置为当前线程。在这种情况下，我想等到aref设置好。最好的方法是什么？

4

5 回答 5

16

您可以使用Await采用更简单的方法。该Await.result方法将超时持续时间作为第二个参数并引发TimeoutException超时。

try {
  import scala.concurrent.duration._
  Await.result(aref, 10 seconds);
} catch {
    case e: TimeoutException => // whatever you want to do.
}
于 2013-05-17T18:37:56.233 回答
6

我也需要相同的行为，所以这就是我解决它的方法。我基本上创建了一个对象，该对象创建一个计时器，如果未来未在指定的持续时间内完成，则使用 TimeoutException 使承诺失败。

package mypackage

import scala.concurrent.{Promise, Future}
import scala.concurrent.duration.FiniteDuration
import akka.actor.ActorSystem
import scala.concurrent.ExecutionContext.Implicits.global

object TimeoutFuture {

  val actorSystem = ActorSystem("myActorSystem")
  def apply[A](timeout: FiniteDuration)(block: => A): Future[A] = {
    val promise = Promise[A]()
    actorSystem.scheduler.scheduleOnce(timeout) {
      promise tryFailure new java.util.concurrent.TimeoutException
    }

    Future {
      try {
        promise success block
      }
      catch {
        case e:Throwable => promise failure e
      } 
    }

    promise.future
  }
}
于 2014-07-15T07:43:04.633 回答
5

如果你添加一个CountDownLatch你可以实现你想要的行为。await（请注意，在很多很多s中阻塞（即卡在 s 处）Future可能会导致线程池饥饿。）

import scala.util.Try
import scala.concurrent.Future

def launch(f: () => Unit, timeout: Int): Future[Try[Unit]] = {

  val aref = new java.util.concurrent.atomic.AtomicReference[Thread]()
  val cdl = new java.util.concurrent.CountDownLatch(1)

  import ExecutionContext.Implicits.global
  Future {Thread.sleep(timeout); cdl.await(); aref.get().interrupt}   // 1
  Future {aref.set(Thread.currentThread); cdl.countDown(); Try(f())}  // 2
}
于 2013-05-17T18:53:00.177 回答
3

尽管您已经得到了一些关于如何通过阻塞附加线程来处理超时来实现它的答案，但我建议您尝试一种不同的方式，原因是 Rex Kerr 已经给出了。我不完全知道你在做什么f()，但如果它是 I/O 绑定的，我建议你只使用异步 I/O 库。如果它是某种循环，您可以将超时值直接传递给该函数并在TimeoutException那里抛出一个，如果它超过超时。例子：

import scala.concurrent.duration._
import java.util.concurrent.TimeoutException

def doSth(timeout: Deadline) = {
  for {
    i <- 0 to 10
  } yield {
    Thread.sleep(1000)
    if (timeout.isOverdue)
      throw new TimeoutException("Operation timed out.")

    i
  }
}

scala> future { doSth(12.seconds.fromNow) }
res3: scala.concurrent.Future[scala.collection.immutable.IndexedSeq[Int]] = 
  scala.concurrent.impl.Promise$DefaultPromise@3d104456

scala> Await.result(res3, Duration.Inf)
res6: scala.collection.immutable.IndexedSeq[Int] =
  Vector(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> future { doSth(2.seconds.fromNow) }
res7: scala.concurrent.Future[scala.collection.immutable.IndexedSeq[Int]] = 
  scala.concurrent.impl.Promise$DefaultPromise@f7dd680

scala> Await.result(res7, Duration.Inf)
java.util.concurrent.TimeoutException: Operation timed out.
    at $anonfun$doSth$1.apply$mcII$sp(<console>:17)
    at $anonfun$doSth$1.apply(<console>:13)
    at $anonfun$doSth$1.apply(<console>:13)
    at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:244)
    ...

scala> res7.value
res10: Option[scala.util.Try[scala.collection.immutable.IndexedSeq[Int]]] =
  Some(Failure(java.util.concurrent.TimeoutException: Operation timed out.))

这将仅使用 1 个线程，该线程将在超时 + 单个步骤的执行时间后终止。

于 2013-05-18T09:06:50.003 回答
1

您也可以尝试使用CountDownLatch这样的：

def launch(f: () => Unit, timeout: Int): Future[Try[Unit]] = {

  val aref = new java.util.concurrent.atomic.AtomicReference[Thread]() 

  import ExecutionContext.Implicits.global
  val latch = new CountDownLatch(1)
  Future {
    latch.await()
    aref.get().interrupt
  }

  Future {
    aref.set(Thread.currentThread) 
    latch.countDown()
    Try(f())
  }
}

现在我一直在等待我的电话latch.await()，但您当然可以将其更改为：

latch.await(1, TimeUnit.SECONDS)

然后用 a 包裹它Try以处理如果何时/如果它超时。

于 2013-05-17T18:53:00.353 回答