Was ist der beste Weg, um wrap-Blockierung Versuch[T] in der Zukunft[T] in Scala?

Hier ist das problem, ich habe eine Bibliothek, die eine blockierende Methode, die return-Versuch[T]. Aber da es eine Sperrung ein, ich möchte es nicht blockierende mit Zukunft[T]. In die Zukunft blockieren, ich möchte auch, um zu berechnen, etwas, das hängt von der Herkunft blockierende Methode auf den Rückgabewert.

Aber wenn ich so etwas wie unten, dann meine nonBlocking zurück Zukunft[Try[T]], die weniger überzeugen, da die Zukunft[T] darstellen könnte Scheitern[U] schon, würde ich eher bevorzugen, propagieren die Ausnahme von Zukunft[T] self.

def blockMethod(x: Int): Try[Int] = Try { 
  //Some long operation to get an Int from network or IO
  throw new Exception("Network Exception") }
}

def nonBlocking(x: Int): Future[Try[Int]] = future {
  blockMethod(x).map(_ * 2)
}

Hier ist, was ich versucht habe, benutze ich nur .get Methode in future {} block, aber ich bin mir nicht sicher, ob dies der beste Weg, das zu tun.

def blockMethod(x: Int): Try[Int] = Try { 
  //Some long operation to get an Int from network or IO
  throw new Exception("Network Exception") }
}

def nonBlocking(x: Int): Future[Int] = future {
  blockMethod(x).get * 2
}

Ist diese richtige Weise, das zu tun? Oder gibt es eine scala idiomatischer Weg, um zu konvertieren t Try[T], um die Zukunft[T]?

InformationsquelleAutor Brian Hsu | 2014-04-18

scala

Hier ist ein Beispiel, das nicht zu blockieren, beachten Sie, dass Sie wahrscheinlich wollen, um mit Ihrem eigenen Ausführungskontext und nicht scala globalen Kontext:

import scala.util._
import scala.concurrent._
import scala.concurrent.duration._
import ExecutionContext.Implicits.global

object Main extends App {

  def blockMethod(x: Int): Try[Int] = Try {
    //Some long operation to get an Int from network or IO
    Thread.sleep(10000)
    100
  }

  def tryToFuture[A](t: => Try[A]): Future[A] = {
    future {
      t
    }.flatMap {
      case Success(s) => Future.successful(s)
      case Failure(fail) => Future.failed(fail)
    }
  }

  //Initiate long operation
  val f = tryToFuture(blockMethod(1))

  println("Waiting... 10 seconds to complete")

  //Should return before 20 seconds...
  val res = Await.result(f, 20 seconds)

  println(res) //prints 100
}

Wenn du weißt, du bist blockiert, sind Sie nicht soll, wickeln Sie den code in blocking?
Könnte die fromTry Methode nützlich sein, für diese? scala-lang.org/api/current/#scala.concurrent.Future$
Self-Korrektur von meinem vorherigen Kommentar: fromTry tatsächlich blockiert, so dass kein Glück gibt.
Ich habe einige Experimente mehr und eigentlich Future(t.get) scheint nicht, um den thread zu blockieren entweder. Es sieht aus wie eine einfachere Lösung eher dann flatMapping. Gedanken?

InformationsquelleAutor Noah

Meiner Meinung nach: Probieren & die Zukunft der monadischen Konstruktion und idiomatischer Weise ist der monadischen Zusammensetzung (für das Verständnis):

Dass Sie brauchen, um zu definieren Monaden-transformer für die Zukunft[Versuchen[_]] (code für Ihre Bibliothek):

case class FutureT[R](run : Future[Try[R]])(implicit e: ExecutionContext) {
  def map[B](f : R => B): FutureT[B] = FutureT(run map { _ map f })
  def flatMap[B](f : R => FutureT[B]): FutureT[B] = {
    val p = Promise[Try[B]]()
    run onComplete {
      case Failure(e)           => p failure e
      case Success(Failure(e))  => p failure e
      case Success(Success(v))  => f(v).run onComplete {
        case Failure(e)         => p failure e
        case Success(s)         => p success s
      }
    }
    FutureT(p.future)
  }
}

object FutureT {
  def futureTry[R](run : => Try[R])(implicit e: ExecutionContext) = 
    new FutureT(future { run })

  implicit def toFutureT[R](run : Future[Try[R]]) = FutureT(run)
  implicit def fromFutureT[R](futureT : FutureT[R]) = futureT.run
}

und Verwendung Beispiel:

def blockMethod(x: Int): Try[Int] = Try {
  Thread.sleep(5000)
  if(x < 10) throw new IllegalArgumentException
  else x + 1
} 

import FutureT._  

//idiomatic way :)
val async = for {
  x <- futureTry { blockMethod(15) }
  y <- futureTry { blockMethod(25) }            
} yield (x + y) * 2  //possible due to using modan transformer  

println("Waiting... 10 seconds to complete")

val res = Await.result(async, 20 seconds)
println(res)

//example with Exception 
val asyncWithError = for {
  x <- futureTry { blockMethod(5) }
  y <- futureTry { blockMethod(25) }            
} yield (x + y) * 2  //possible due to using modan transformer  

//Can't use Await because will get exception 
//when extract value from FutureT(Failure(java.lang.IllegalArgumentException))
//no difference between Failure produced by Future or Try
asyncWithError onComplete {
  case Failure(e) => println(s"Got exception: $e.msg")
  case Success(res) => println(res)
}
//Output:
//Got exception: java.lang.IllegalArgumentException.msg

es ist ein Fehler irgendwo. ändern blockMethod(15) durch blockMethod(5) Ergebnisse in einer exception beendet das Programm, und die Letzte Zeile println(res) wird nicht ausgeführt.
Danke David, ich verpasste Beschreibung für Exception-Verhalten, update meine Antwort mit Exception-Beispiel.

InformationsquelleAutor Yuriy

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.