blocks|key|207025|text|您可以在等待将来时指定超时时间：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|207026|对于scala.concurrent.Future，result方法允许您指定超时。|offset|length|style|CODE|207027|对于scala.actors.Future，Futures.awaitAll允许您指定超时。|207028|我认为在执行未来时没有内置的超时。|207029|entityMap^0|0|2|N|Q|6|0|2|J|M|G|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@$D|P|E|Q|F|G]|$D|R|E|S|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|T|8|@$D|U|E|V|F|G]|$D|W|E|X|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|Y|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|M|$]]

You can specify the timeout when you wait on the future:

For <code>scala.concurrent.Future</code>, the <code>result</code> method lets you specify a timeout.

For <code>scala.actors.Future</code>, <code>Futures.awaitAll</code> lets you specify a timeout.

I do not think there is a timeout built-in the execution of a Future.

blocks|key|205026|text|只有当您使用阻塞来获取Future的结果时，才会获得超时行为。如果您想使用非阻塞回调onComplete、onSuccess或onFailure，那么您必须使用自己的超时处理。Akka为参与者之间的请求/响应(?)消息传递内置了超时处理，但不确定是否要开始使用Akka。在Akka的FWIW中，为了处理超时，它们通过Future.firstCompletedOf将两个Futures组合在一起，一个表示实际的异步任务，另一个表示超时。如果超时计时器(通过HashedWheelTimer)首先弹出，则异步回调会失败。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|205027|一个非常简单的滚动你自己的例子可能是这样的。首先，一个用于调度超时的对象：|205028|import+org.jboss.netty.util.{HashedWheelTimer,+TimerTask,+Timeout}
import+java.util.concurrent.TimeUnit
import+scala.concurrent.duration.Duration
import+scala.concurrent.Promise
import+java.util.concurrent.TimeoutException

object+TimeoutScheduler{
++val+timer+=+new+HashedWheelTimer(10,+TimeUnit.MILLISECONDS)
++def+scheduleTimeout(promise:Promise[_],+after:Duration)+=+{
++++timer.newTimeout(new+TimerTask{
++++++def+run(timeout:Timeout){++++++++++++++
++++++++promise.failure(new+TimeoutException("Operation+timed+out+after+"+%2B+after.toMillis+%2B+"+millis"))++++++++
++++++}
++++},+after.toNanos,+TimeUnit.NANOSECONDS)
++}
}|code-block|syntax|javascript|205029|然后使用一个函数take+a+Future并为其添加超时行为：|205030|import+scala.concurrent.{Future,+ExecutionContext,+Promise}
import+scala.concurrent.duration.Duration

def+withTimeout[T](fut:Future[T])(implicit+ec:ExecutionContext,+after:Duration)+=+{
++val+prom+=+Promise[T]()
++val+timeout+=+TimeoutScheduler.scheduleTimeout(prom,+after)
++val+combinedFut+=+Future.firstCompletedOf(List(fut,+prom.future))
++fut+onComplete{case+result+=>+timeout.cancel()}
++combinedFut
}|205031|请注意，我在这里使用的HashedWheelTimer来自Netty。|205032|entityMap^0|B|6|16|A|1H|9|1R|9|2X|1|4E|N|54|7|6B|G|0|0|0|0|0|B|G|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1B|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1C|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1D|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1E|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1F|8|@$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1I|8|@]|D|@]|E|$]]]|T|$]]

You only get timeout behavior when you use blocking to get the results of the <code>Future</code>. If you want to use the non-blocking callbacks <code>onComplete</code>, <code>onSuccess</code> or <code>onFailure</code>, then you would have to roll your own timeout handling. Akka has built in timeout handling for request/response (<code>?</code>) messaging between actors, but not sure if you want to start using Akka. FWIW, in Akka, for timeout handling, they compose two <code>Futures</code> together via <code>Future.firstCompletedOf</code>, one which represents the actual async task and one that represents the timeout. If the timeout timer (via a <code>HashedWheelTimer</code>) pops first, you get a failure on the async callback.

A very simplified example of rolling your own might go something like this. First, an object for scheduling timeouts:

<pre><code>import org.jboss.netty.util.{HashedWheelTimer, TimerTask, Timeout}
import java.util.concurrent.TimeUnit
import scala.concurrent.duration.Duration
import scala.concurrent.Promise
import java.util.concurrent.TimeoutException

object TimeoutScheduler{
 val timer = new HashedWheelTimer(10, TimeUnit.MILLISECONDS)
 def scheduleTimeout(promise:Promise[_], after:Duration) = {
 timer.newTimeout(new TimerTask{
 def run(timeout:Timeout){ 
 promise.failure(new TimeoutException("Operation timed out after " + after.toMillis + " millis")) 
 }
 }, after.toNanos, TimeUnit.NANOSECONDS)
 }
}
</code></pre>

Then a function to take a Future and add timeout behavior to it:

<pre><code>import scala.concurrent.{Future, ExecutionContext, Promise}
import scala.concurrent.duration.Duration

def withTimeout[T](fut:Future[T])(implicit ec:ExecutionContext, after:Duration) = {
 val prom = Promise[T]()
 val timeout = TimeoutScheduler.scheduleTimeout(prom, after)
 val combinedFut = Future.firstCompletedOf(List(fut, prom.future))
 fut onComplete{case result =&gt; timeout.cancel()}
 combinedFut
}
</code></pre>

Note that the <code>HashedWheelTimer</code> I am using here is from Netty.

blocks|key|207045|text|我刚刚为一个同事创建了一个TimeoutFuture类：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|207046|TimeoutFuture|207047|package+model

import+scala.concurrent._
import+scala.concurrent.duration._
import+play.libs.Akka
import+play.api.libs.concurrent.Execution.Implicits._

object+TimeoutFuture+{
++def+apply[A](timeout:+FiniteDuration)(block:+=>+A):+Future[A]+=+{

++++val+prom+=+promise[A]

++++//+timeout+logic
++++Akka.system.scheduler.scheduleOnce(timeout)+{
++++++prom+tryFailure+new+java.util.concurrent.TimeoutException
++++}

++++//+business+logic
++++Future+{+
++++++prom+success+block
++++}

++++prom.future
++}+
}|code-block|syntax|javascript|207048|用法|207049|val+future+=+TimeoutFuture(10+seconds)+{+
++//+do+stuff+here
}

future+onComplete+{
++case+Success(stuff)+=>+//+use+"stuff"
++case+Failure(exception)+=>+//+catch+exception+(either+TimeoutException+or+an+exception+inside+the+given+block)
}|207050|备注：|207051|207052|采取行动！框架(但它很容易适应)|unordered-list-item|207053|每段代码都运行在同一个ExecutionContext中，这可能并不理想。|207054|207055|entityMap^0|D|D|0|0|0|0|0|0|0|0|B|G|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|14|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|15|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|16|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|17|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|18|8|@]|D|@]|E|$]]|$1|S|3|-4|5|6|7|19|8|@]|D|@]|E|$]]|$1|T|3|U|5|V|7|1A|8|@]|D|@]|E|$]]|$1|W|3|X|5|V|7|1B|8|@$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|Y|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]|$1|Z|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]]|10|$]]

I've just created a <code>TimeoutFuture</code> class for a coworker:

<h2>TimeoutFuture</h2>

<pre><code>package model

import scala.concurrent._
import scala.concurrent.duration._
import play.libs.Akka
import play.api.libs.concurrent.Execution.Implicits._

object TimeoutFuture {
 def apply[A](timeout: FiniteDuration)(block: =&gt; A): Future[A] = {

 val prom = promise[A]

 // timeout logic
 Akka.system.scheduler.scheduleOnce(timeout) {
 prom tryFailure new java.util.concurrent.TimeoutException
 }

 // business logic
 Future { 
 prom success block
 }

 prom.future
 } 
}
</code></pre>

<h2>Usage</h2>

<pre><code>val future = TimeoutFuture(10 seconds) { 
 // do stuff here
}

future onComplete {
 case Success(stuff) =&gt; // use "stuff"
 case Failure(exception) =&gt; // catch exception (either TimeoutException or an exception inside the given block)
}
</code></pre>

<h2>Notes:</h2>

<ul>
<li>Assumes Play! framework (but it's easy enough to adapt)</li>
<li>Every piece of code runs in the same <code>ExecutionContext</code> which may not be ideal.</li>
</ul>

blocks|key|1046600|text|Play框架包含Promise.timeout，因此您可以编写如下代码|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1046601|private+def+get():+Future[Option[Boolean]]+=+{
++val+timeoutFuture+=+Promise.timeout(None,+Duration("1s"))
++val+mayBeHaveData+=+Future{
++++//+do+something
++++Some(true)
++}

++//+if+timeout+occurred+then+None+will+be+result+of+method
++Future.firstCompletedOf(List(mayBeHaveData,+timeoutFuture))
}|code-block|syntax|javascript|1046602|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Play framework contains Promise.timeout so you can write code like following

<pre><code>private def get(): Future[Option[Boolean]] = {
 val timeoutFuture = Promise.timeout(None, Duration("1s"))
 val mayBeHaveData = Future{
 // do something
 Some(true)
 }

 // if timeout occurred then None will be result of method
 Future.firstCompletedOf(List(mayBeHaveData, timeoutFuture))
}
</code></pre>

blocks|key|1046665|text|我很惊讶这不是Scala的标准。我的版本很短，没有依赖关系|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1046666|import+scala.concurrent.Future

sealed+class+TimeoutException+extends+RuntimeException

object+FutureTimeout+{

++import+scala.concurrent.ExecutionContext.Implicits.global

++implicit+class+FutureTimeoutLike[T](f:+Future[T])+{
++++def+withTimeout(ms:+Long):+Future[T]+=+Future.firstCompletedOf(List(f,+Future+{
++++++Thread.sleep(ms)
++++++throw+new+TimeoutException
++++}))

++++lazy+val+withTimeout:+Future[T]+=+withTimeout(2000)+//+default+2s+timeout
++}

}|code-block|syntax|javascript|1046667|使用示例|1046668|import+FutureTimeout._
Future+{+/*+do+smth+*/+}+withTimeout|1046669|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I'm quite surprise this is not standard in Scala. My versions is short and has no dependencies

<pre><code>import scala.concurrent.Future

sealed class TimeoutException extends RuntimeException

object FutureTimeout {

 import scala.concurrent.ExecutionContext.Implicits.global

 implicit class FutureTimeoutLike[T](f: Future[T]) {
 def withTimeout(ms: Long): Future[T] = Future.firstCompletedOf(List(f, Future {
 Thread.sleep(ms)
 throw new TimeoutException
 }))

 lazy val withTimeout: Future[T] = withTimeout(2000) // default 2s timeout
 }

}
</code></pre>

Usage example

<pre><code>import FutureTimeout._
Future { /* do smth */ } withTimeout
</code></pre>

blocks|key|3172817|text|到目前为止还没有人提到akka-streams。这些流有一个简单的completionTimeout方法，并将其应用于单一源码流，就像一个未来。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3172818|但是，akka-streams也执行取消操作，因此它实际上可以终止源程序的运行，即它向源程序发出超时信号。|3172819|entityMap|0|LINK|mutability|MUTABLE|url|http://doc.akka.io/docs/akka/2.4.10/scala/stream/stages-overview.html#completiontimeout^0|B|C|X|H|X|H|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@$9|U|A|V|1|W]]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]]]

Nobody's mentioned <code>akka-streams</code>, yet. The flows have an easy <a href="http://doc.akka.io/docs/akka/2.4.10/scala/stream/stages-overview.html#completiontimeout" rel="nofollow"><code>completionTimeout</code></a> method, and applying that on a single-source stream works like a Future.

But, akka-streams also does cancellation so it can actually end the source from running, i.e. it signals the timeout to the source.

blocks|key|205159|text|如果您希望写入者(promise+holder)是控制超时逻辑的人，请按以下方式使用akka.pattern.after：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|205160|val+timeout+=+akka.pattern.after(10+seconds,+system.scheduler)(Future.failed(new+TimeoutException(s"timed+out+during...")))
Future.firstCompletedOf(Seq(promiseRef.future,+timeout))|code-block|syntax|javascript|205161|这样，即使您的promise+completed逻辑从未发生，您的调用者的未来仍将在某个时候以失败告终。|205162|entityMap|0|LINK|mutability|MUTABLE|url|http://doc.akka.io/docs/akka/current/scala/futures.html#After^0|16|I|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

If you want the writer (promise holder) to be the one who controls the timeout logic, use <a href="http://doc.akka.io/docs/akka/current/scala/futures.html#After" rel="noreferrer">akka.pattern.after</a>, in the following way:

<pre><code>val timeout = akka.pattern.after(10 seconds, system.scheduler)(Future.failed(new TimeoutException(s"timed out during...")))
Future.firstCompletedOf(Seq(promiseRef.future, timeout))
</code></pre>

This way, if your promise completion logic never takes place, your caller's future will still be completed at some point with a failure.

blocks|key|205183|text|所有这些答案都需要额外的依赖项。我决定使用java.util.Timer编写一个版本，这是一种在将来运行函数的有效方式，在这种情况下是触发超时。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|205184|Blog+post+with+more+details+here|offset|length|205185|使用Scala的承诺，我们可以创建一个具有超时的未来，如下所示：|205186|package+justinhj.concurrency

import+java.util.concurrent.TimeoutException
import+java.util.{Timer,+TimerTask}

import+scala.concurrent.duration.FiniteDuration
import+scala.concurrent.{ExecutionContext,+Future,+Promise}
import+scala.language.postfixOps

object+FutureUtil+{

++//+All+Future's+that+use+futureWithTimeout+will+use+the+same+Timer+object
++//+it+is+thread+safe+and+scales+to+thousands+of+active+timers
++//+The+true+parameter+ensures+that+timeout+timers+are+daemon+threads+and+do+not+stop
++//+the+program+from+shutting+down

++val+timer:+Timer+=+new+Timer(true)

++/**
++++*+Returns+the+result+of+the+provided+future+within+the+given+time+or+a+timeout+exception,+whichever+is+first
++++*+This+uses+Java+Timer+which+runs+a+single+thread+to+handle+all+futureWithTimeouts+and+does+not+block+like+a
++++*+Thread.sleep+would
++++*+@param+future+Caller+passes+a+future+to+execute
++++*+@param+timeout+Time+before+we+return+a+Timeout+exception+instead+of+future's+outcome
++++*+@return+Future[T]
++++*/
++def+futureWithTimeout[T](future+:+Future[T],+timeout+:+FiniteDuration)(implicit+ec:+ExecutionContext):+Future[T]+=+{

++++//+Promise+will+be+fulfilled+with+either+the+callers+Future+or+the+timer+task+if+it+times+out
++++val+p+=+Promise[T]

++++//+and+a+Timer+task+to+handle+timing+out

++++val+timerTask+=+new+TimerTask()+{
++++++def+run()+:+Unit+=+{
++++++++++++p.tryFailure(new+TimeoutException())
++++++++}
++++++}

++++//+Set+the+timeout+to+check+in+the+future
++++timer.schedule(timerTask,+timeout.toMillis)

++++future.map+{
++++++a+=>
++++++++if(p.trySuccess(a))+{
++++++++++timerTask.cancel()
++++++++}
++++}
++++.recover+{
++++++case+e:+Exception+=>
++++++++if(p.tryFailure(e))+{
++++++++++timerTask.cancel()
++++++++}
++++}

++++p.future
++}

}|code-block|syntax|javascript|205187|entityMap|0|LINK|mutability|MUTABLE|url|http://justinhj.github.io/2017/07/16/future-with-timeout.html^0|0|0|W|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@$D|W|E|X|1|Y]]|A|$]]|$1|F|3|G|5|6|7|Z|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

All of these answers require additional dependencies. I decided to write a version using java.util.Timer which is an efficient way to run a function in the future, in this case to trigger a timeout. 

<a href="http://justinhj.github.io/2017/07/16/future-with-timeout.html" rel="noreferrer">Blog post with more details here</a>

Using this with Scala's Promise, we can make a Future with timeout as follows: 

<pre><code>package justinhj.concurrency

import java.util.concurrent.TimeoutException
import java.util.{Timer, TimerTask}

import scala.concurrent.duration.FiniteDuration
import scala.concurrent.{ExecutionContext, Future, Promise}
import scala.language.postfixOps

object FutureUtil {

 // All Future's that use futureWithTimeout will use the same Timer object
 // it is thread safe and scales to thousands of active timers
 // The true parameter ensures that timeout timers are daemon threads and do not stop
 // the program from shutting down

 val timer: Timer = new Timer(true)

 /**
 * Returns the result of the provided future within the given time or a timeout exception, whichever is first
 * This uses Java Timer which runs a single thread to handle all futureWithTimeouts and does not block like a
 * Thread.sleep would
 * @param future Caller passes a future to execute
 * @param timeout Time before we return a Timeout exception instead of future's outcome
 * @return Future[T]
 */
 def futureWithTimeout[T](future : Future[T], timeout : FiniteDuration)(implicit ec: ExecutionContext): Future[T] = {

 // Promise will be fulfilled with either the callers Future or the timer task if it times out
 val p = Promise[T]

 // and a Timer task to handle timing out

 val timerTask = new TimerTask() {
 def run() : Unit = {
 p.tryFailure(new TimeoutException())
 }
 }

 // Set the timeout to check in the future
 timer.schedule(timerTask, timeout.toMillis)

 future.map {
 a =&gt;
 if(p.trySuccess(a)) {
 timerTask.cancel()
 }
 }
 .recover {
 case e: Exception =&gt;
 if(p.tryFailure(e)) {
 timerTask.cancel()
 }
 }

 p.future
 }

}
</code></pre>

blocks|key|205216|text|我使用这个版本(基于上面的Play示例)，它使用Akka系统调度程序：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|205217|object+TimeoutFuture+{
++def+apply[A](system:+ActorSystem,+timeout:+FiniteDuration)(block:+=>+A):+Future[A]+=+{
++++implicit+val+executionContext+=+system.dispatcher

++++val+prom+=+Promise[A]

++++//+timeout+logic
++++system.scheduler.scheduleOnce(timeout)+{
++++++prom+tryFailure+new+java.util.concurrent.TimeoutException
++++}

++++//+business+logic
++++Future+{
++++++try+{
++++++++prom+success+block
++++++}+catch+{
++++++++case+t:+Throwable+=>+prom+tryFailure+t
++++++}
++++}

++++prom.future
++}
}|code-block|syntax|javascript|205218|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I'm using this version (based on Play example above) which uses Akka system dispatcher:

<pre><code>object TimeoutFuture {
 def apply[A](system: ActorSystem, timeout: FiniteDuration)(block: =&gt; A): Future[A] = {
 implicit val executionContext = system.dispatcher

 val prom = Promise[A]

 // timeout logic
 system.scheduler.scheduleOnce(timeout) {
 prom tryFailure new java.util.concurrent.TimeoutException
 }

 // business logic
 Future {
 try {
 prom success block
 } catch {
 case t: Throwable =&gt; prom tryFailure t
 }
 }

 prom.future
 }
}
</code></pre>

blocks|key|3173008|text|Monix+Task有超时support|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3173009|import+monix.execution.Scheduler.Implicits.global
import+monix.eval._
import+scala.concurrent.duration._
import+scala.concurrent.TimeoutException

val+source+=+Task("Hello!").delayExecution(10.seconds)

//+Triggers+error+if+the+source+does+not+complete+in+3+seconds+after+runOnComplete
val+timedOut+=+source.timeout(3.seconds)

timedOut.runOnComplete(r+=>+println(r))
//=>+Failure(TimeoutException)|code-block|syntax|javascript|3173010|entityMap|0|LINK|mutability|MUTABLE|url|https://monix.io/docs/3x/eval/task.html#trigger-a-timeout^0|6|4|D|7|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@$9|V|A|W|1|X]]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

Monix <code>Task</code> has timeout <a href="https://monix.io/docs/3x/eval/task.html#trigger-a-timeout" rel="nofollow noreferrer">support</a>

<pre><code>import monix.execution.Scheduler.Implicits.global
import monix.eval._
import scala.concurrent.duration._
import scala.concurrent.TimeoutException

val source = Task("Hello!").delayExecution(10.seconds)

// Triggers error if the source does not complete in 3 seconds after runOnComplete
val timedOut = source.timeout(3.seconds)

timedOut.runOnComplete(r =&gt; println(r))
//=&gt; Failure(TimeoutException)
</code></pre>

blocks|key|205231|text|这个版本不需要使用任何外部计时器(只有Await.result)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|205232|import+scala.concurrent._
import+scala.concurrent.duration.FiniteDuration

object+TimeoutFuture+{
++++def+apply[A](
++++++++timeout:+FiniteDuration
++++)(block:+=>+A)(implicit+executor:+ExecutionContext):+Future[A]+=
++++++++try+{
++++++++++++Future+{+Await.result(Future+{+block+},+timeout)+}
++++++++}+catch+{
++++++++++++case+_:+TimeoutException+=>+Future.failed(new+TimeoutException(s"Timed+out+after+${timeout.toString}"))
++++++++}
}|code-block|syntax|javascript|205233|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This version works without using any external timer (just Await.result)

<pre><code>import scala.concurrent._
import scala.concurrent.duration.FiniteDuration

object TimeoutFuture {
 def apply[A](
 timeout: FiniteDuration
 )(block: =&gt; A)(implicit executor: ExecutionContext): Future[A] =
 try {
 Future { Await.result(Future { block }, timeout) }
 } catch {
 case _: TimeoutException =&gt; Future.failed(new TimeoutException(s"Timed out after ${timeout.toString}"))
 }
}
</code></pre>

blocks|key|1345837|text|在Future+IMO上指定超时的最简单方法是使用scala.concurrent.Await.ready的scala内置机制，这将在Future花费的时间超过指定的超时时抛出TimeoutException。否则，它将返回Future本身。下面是一个简单的人为设计的例子|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1345838|import+scala.concurrent.ExecutionContext.Implicits._
import+scala.concurrent.duration._
val+f1:+Future[Int]+=+Future+{
++Thread.sleep(1100)
++5
}

val+fDoesntTimeout:+Future[Int]+=+Await.ready(f1,+2000+milliseconds)

val+f:+Future[Int]+=+Future+{
++Thread.sleep(1100)
++5
}
val+fTimesOut:+Future[Int]+=+Await.ready(f,+100+milliseconds)|code-block|syntax|javascript|1345839|entityMap^0|P|S|2G|G|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

The simplest way to specify timeout on Future IMO is scala's built in mechanism using <code>scala.concurrent.Await.ready</code> This will throw a <code>TimeoutException</code> if the Future takes longer than the specified timeout. Otherwise, it will return the Future itself. 
Here is a simple contrived example

<pre><code>import scala.concurrent.ExecutionContext.Implicits._
import scala.concurrent.duration._
val f1: Future[Int] = Future {
 Thread.sleep(1100)
 5
}

val fDoesntTimeout: Future[Int] = Await.ready(f1, 2000 milliseconds)

val f: Future[Int] = Future {
 Thread.sleep(1100)
 5
}
val fTimesOut: Future[Int] = Await.ready(f, 100 milliseconds)
</code></pre>

blocks|key|3173188|text|您可以使用Await等待将来的完成。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3173189|import+scala.concurrent.duration._
import+scala.concurrent.{Await,+Future}

val+meaningOfLife:+Int+=+Await.result(Future(42),+1.nano)
println+(meaningOfLife)|code-block|syntax|javascript|3173190|上面的代码打印42|3173191|在这种情况下，您可能需要一个可用的隐式ExecutionContext，只需添加：|3173192|import+scala.concurrent.ExecutionContext.Implicits.global|3173193|3173194|另一种方法是使用monix中的Coeval。这种方法并不是在所有情况下都有效，您可以在here上阅读有关它的所有内容。其基本思想是，有时未来并不真正花费任何时间，而是返回同步函数调用或值的结果，因此可以在当前线程上计算这个未来。这对于测试和模拟期货也很有用。此外，您不必指定预期的超时，但不必担心这一点仍然很好。|3173195|您首先将未来转换为Task，并将该任务包装在Coeval中，然后在等待时祈祷看您会得到什么。这是一个非常简单的例子来说明它是如何工作的：|3173196|您需要一个隐式Scheduler才能使用它：|3173197|import+monix.execution.Scheduler.Implicits.global|3173198|Coeval(Task.fromFuture(Future+(42)).runSyncStep).value()+match+{
+++case+Right(v)+=>+println(v)
+++case+Left(task)+=>+println("Task+did+not+finish")
}|3173199|以上操作完成并将42输出到控制台。|3173200|Coeval(Task.fromFuture(Future+{
+++scala.concurrent.blocking+{
++++++42
+++}
}).runSyncStep).value()+match+{
+++case+Right(v)+=>+println(v)
+++case+Left(task)+=>+println("Task+did+not+finish")
}|3173201|此示例打印Task+did+not+finish|3173202|entityMap|0|LINK|mutability|MUTABLE|url|https://monix.io/|1|https://monix.io/docs/3x/eval/task.html#try-immediate-execution-coeval^0|5|5|0|0|7|2|0|J|G|0|0|0|F|6|8|5|0|17|4|1|0|9|4|M|6|0|7|9|0|0|0|8|2|0|0|5|J|0^^$0|@$1|2|3|4|5|6|7|1H|8|@$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1K|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1L|8|@$9|1M|A|1N|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|1O|8|@$9|1P|A|1Q|B|C]]|D|@]|E|$]]|$1|O|3|P|5|H|7|1R|8|@]|D|@]|E|$I|J]]|$1|Q|3|-4|5|6|7|1S|8|@]|D|@]|E|$]]|$1|R|3|S|5|6|7|1T|8|@$9|1U|A|1V|B|C]]|D|@$9|1W|A|1X|1|1Y]|$9|1Z|A|20|1|21]]|E|$]]|$1|T|3|U|5|6|7|22|8|@$9|23|A|24|B|C]|$9|25|A|26|B|C]]|D|@]|E|$]]|$1|V|3|W|5|6|7|27|8|@$9|28|A|29|B|C]]|D|@]|E|$]]|$1|X|3|Y|5|H|7|2A|8|@]|D|@]|E|$I|J]]|$1|Z|3|10|5|H|7|2B|8|@]|D|@]|E|$I|J]]|$1|11|3|12|5|6|7|2C|8|@$9|2D|A|2E|B|C]]|D|@]|E|$]]|$1|13|3|14|5|H|7|2F|8|@]|D|@]|E|$I|J]]|$1|15|3|16|5|6|7|2G|8|@$9|2H|A|2I|B|C]]|D|@]|E|$]]|$1|17|3|-4|5|6|7|2J|8|@]|D|@]|E|$]]]|18|$19|$5|1A|1B|1C|E|$1D|1E]]|1F|$5|1A|1B|1C|E|$1D|1G]]]]

You can wait for a future to finish by making use of <code>Await</code>.

<pre><code>import scala.concurrent.duration._
import scala.concurrent.{Await, Future}

val meaningOfLife: Int = Await.result(Future(42), 1.nano)
println (meaningOfLife)
</code></pre>

The above prints <code>42</code>

You may need an implicit <code>ExecutionContext</code> available in which case, just add:

<pre><code>import scala.concurrent.ExecutionContext.Implicits.global
</code></pre>

<hr>

Another way to do it is to use <code>Coeval</code> from <a href="https://monix.io/" rel="nofollow noreferrer">monix</a>. This method does not work in all situations, and you can read all about it <a href="https://monix.io/docs/3x/eval/task.html#try-immediate-execution-coeval" rel="nofollow noreferrer">here</a>.
The basic idea is that sometimes a future does not really take any time and is returning the result of a synchronous function call or value, so this future can be evaluated on the current thread. This is also useful for testing and mocking futures. Also you don't have to specify a timeout which is expected, but still nice to not have to worry about that.

You start by transforming the future into a <code>Task</code> and wrap that task in a <code>Coeval</code> then cross your fingers as you wait to see what you get. This is a very simple example to show how it works:

You need an implicit <code>Scheduler</code> to be able to use it:

<pre><code>import monix.execution.Scheduler.Implicits.global
</code></pre>

 

<pre><code>Coeval(Task.fromFuture(Future (42)).runSyncStep).value() match {
 case Right(v) =&gt; println(v)
 case Left(task) =&gt; println("Task did not finish")
}
</code></pre>

The above completes and prints <code>42</code> to the console.

<pre><code>Coeval(Task.fromFuture(Future {
 scala.concurrent.blocking {
 42
 }
}).runSyncStep).value() match {
 case Right(v) =&gt; println(v)
 case Left(task) =&gt; println("Task did not finish")
}
</code></pre>

This example prints <code>Task did not finish</code>:

blocks|key|205294|text|You+can+simply+run+the+future+to+completion+without+giving+any+timeout+interval+by+setting+the+timeout+to+infinite+as+below:

**import+scala.concurrent.duration._++
Await.result(run(executionContext),+Duration.Inf)**

run+function+can+be+as+below+:

def+run(implicit+ec:+ExecutionContext)+=+{++
++++++val+list+=+Seq(++
++++++++++Future+{+println("start+1");+Thread.sleep(1000);+println("stop+1")},++
++++++++++Future+{+println("start+2");+Thread.sleep(2000);+println("stop+2")},++
++++++++++Future+{+println("start+3");+Thread.sleep(3000);+println("stop+3")},++
++++++++++Future+{+println("start+4");+Thread.sleep(4000);+println("stop+4")},++
++++++++++Future+{+println("start+5");+Thread.sleep(5000);+println("stop+5")}++
++++++)++
++++++Future.sequence(list)++
++++}++|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|205295|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>You can simply run the future to completion without giving any timeout interval by setting the timeout to infinite as below:

**import scala.concurrent.duration._ 
Await.result(run(executionContext), Duration.Inf)**

run function can be as below :

def run(implicit ec: ExecutionContext) = { 
 val list = Seq( 
 Future { println("start 1"); Thread.sleep(1000); println("stop 1")}, 
 Future { println("start 2"); Thread.sleep(2000); println("stop 2")}, 
 Future { println("start 3"); Thread.sleep(3000); println("stop 3")}, 
 Future { println("start 4"); Thread.sleep(4000); println("stop 4")}, 
 Future { println("start 5"); Thread.sleep(5000); println("stop 5")} 
 ) 
 Future.sequence(list) 
 } 
</code></pre>

there is an aspect of futures that I do not exactly understand from the official tutorial ref. <a href="http://docs.scala-lang.org/overviews/core/futures.html">http://docs.scala-lang.org/overviews/core/futures.html</a>

Do futures in scala have a built in time-out mechanism of some kind? Let's say the example below was a 5 gigabyte text file... does the implied scope of "Implicits.global" eventually cause onFailure to fire in a non-blocking way or can that be defined? And without a default time-out of some kind, wouldn't that imply it's possible neither success nor failure would ever fire? 

<pre><code>import scala.concurrent._
import ExecutionContext.Implicits.global

val firstOccurence: Future[Int] = future {
 val source = scala.io.Source.fromFile("myText.txt")
 source.toSeq.indexOfSlice("myKeyword")
}
firstOccurence onSuccess {
 case idx =&gt; println("The keyword first appears at position: " + idx)
}
firstOccurence onFailure {
 case t =&gt; println("Could not process file: " + t.getMessage)
}
</code></pre>

Scala Futures - built in timeout?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

从官方教程参考中，我不能完全理解未来的一个方面。scala中的期货是否有某种内置的超时机制？假设下面的例子是一个5‘s的文本文件..."Implicits.global“的隐含作用域最终会导致onFailure以非阻塞方式触发吗?还是可以定义？如果没有某种类型的默认超时，这是否意味着成功或失败都不会触发？import ...

问Scala Futures -内置超时？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Scala Futures -内置超时？EN