¿Hay una función estándar de Scala para ejecutar un bloque con un tiempo de espera?

Question

Necesito llamar a un servicio que puede o no devolver resultados oportunos. Me gustaría ser capaz de escribir

val result = runWithTimeout(5000, valReturnedOnTimeout) { service.fetch } 

¿Hay una función estándar que hará el trabajo - como Ruby de timeout?

Answer 1

Con el crédito a las otras respuestas - en la ausencia de cualquier función de biblioteca estándar, he seguido la ruta Futures.

import scala.concurrent._ 
    import scala.concurrent.duration._ 

    def runWithTimeout[T](timeoutMs: Long)(f: => T) : Option[T] = { 
    Await.result(Future(f), timeMins milliseconds).asInstanceOf[Option[T]] 
    } 

    def runWithTimeout[T](timeoutMs: Long, default: T)(f: => T) : T = { 
    runWithTimeout(timeoutMs)(f).getOrElse(default) 
    } 

Para que

@Test def test { 
    runWithTimeout(50) { "result" } should equal (Some("result")) 
    runWithTimeout(50) { Thread.sleep(100); "result" } should equal (None) 
    runWithTimeout(50, "no result") { "result" } should equal ("result") 
    runWithTimeout(50, "no result") { Thread.sleep(100); "result" } should equal("no result") 
    } 

Estaría agradecido por cualquier información sobre si este es un buen estilo Scala!

Answer 2

Puede iniciarlo en un nuevo subproceso y esperar a que termine con Thread.join. Si pasa un parámetro para unirse, espera como máximo esos milisegundos.

val t = new Thread { 
    override def run() { 
    //... 
    } 
} 
t.start() 
t.join(5000) 

Answer 3

Poder Futures y su alarm hacer el truco?

Answer 4

Se puede usar un futuro

import scala.actors.Futures._ 

val myfuture = 
    future { 
    Thread.sleep(5000) 
    println("<future>") 
    "future " 
} 

awaitAll(300,myfuture) foreach println _ 

Pero también echar un vistazo a Circuit Breaker for Scala que es una aplicación de la Circuit Breaker Pattern. Básicamente se le permite controlar el tiempo de espera y lo que debe suceder si se produce un fallo para acceder a un recurso externo

uso es la siguiente con Scala (desde el readme):

. . . 
addCircuitBreaker("test", CircuitBreakerConfiguration(timeout=100,failureThreshold=10)) 
. . . 


class Test extends UsingCircuitBreaker { 
    def myMethodWorkingFine = { 
    withCircuitBreaker("test") { 
     . . . 
    } 
    } 

    def myMethodDoingWrong = { 
    withCircuitBreaker("test") { 
     require(false,"FUBAR!!!") 
    } 
    } 
} 

Answer 5

Algo que no se ha mencionado aún es awaitEither, un método en el objeto Futures del paquete de actores. awaitEither devuelve el resultado de la primera de un par de futuros para completar, así que por ejemplo algo como esto podría ser utilizado:

awaitEither(future{task}, alarm(timeoutPeriod)) 

y luego vestido con un método como se sugiere:

def runWithTimeout[T](timeoutPeriod: Int, timeoutValue: T)(task: => T) = { 
    awaitEither(future{task}, alarm(timeoutPeriod)) match {case() => timeoutValue case x => x} 
} 

alarma devuelve unidad que se puede asignar a un val de tipo Cualquiera que esté tan esperado. Devuelve algo que puede coincidir con un patrón.