Sollte ich den block auf eine Zukunft – scala

Laut Scala Dokumentation, keine Blockierung getan werden sollte, auf Zukunft.

„Wie bereits erwähnt, ist die Blockierung auf eine Zukunft, wird dringend abgeraten, aus Gründen der Leistung und für die Vermeidung von deadlocks. Rückrufe und combinators auf futures sind eine bevorzugte Möglichkeit zur Nutzung Ihrer Ergebnisse. Jedoch, die Sperrung kann notwendig sein, in bestimmten Situationen und wird unterstützt durch die Futures und Verspricht API“.

Wie kann ich sicherstellen, dass meine all die Futures abgeschlossen haben (und die Rückrufe fertig), bevor mein Programm beendet? Ich verwende in der Regel Erwarten.Ergebnis am Ende der main-Funktion, um sicherzustellen, dass alle Futures abgeschlossen haben.

object ConcurrencyExample extends App {
val gpf= Future {some operations}
val ccf = Future{some operations}


val atbf = for {g <- gpf
c <- ccf if c == true}  yield {some operations}

//is it OK to use Await? If not, how do I ensure that all Futures have finished
        ?
Await.result(atbf,1000 millis )
 }

Fragen

  1. Ist über Erwarten falsch? Mein code kann nicht warten, für die Zukunft auf fertig stellen, sonst
  2. Wenn ja, Was ist die alternative?
  3. Wie Stelle ich sicher, dass die Zukunft und seine callback abgeschlossen haben, bevor mein main Programm beendet ?
InformationsquelleAutor Manu Chadha | 2016-12-29



One Reply
  1. 7

    Kann man ja Await.result in Ihrem Fall.

    Können Sie Await.result für die Aufbewahrung Haupt-thread am Leben für futures abschließen

    Becareful mit dem Erwarten.Ergebnis

    Beachten Sie, dies gilt für beide Akka und play-apps

    Await.result sollten sehr vorsichtig verwendet werden, nur, wenn es absolut notwendig ist.

    Await.result blockiert den thread in dem es ausgeführt wird, bis die angegebene Dauer. Die Blockierung der thread verschwenden die kostbare Berechnung Ressource, weil das Gewinde nicht in der Lage zu tun, jede nützliche Berechnungen, wie etwa die Handhabung der neuen Anfrage oder der Anzahl Knirschen in einen Algorithmus etc.

    So, Vermeiden Sie die Verwendung der Await.result so viel wie möglich.

    Aber, wenn wir es Erwarten.Ergebnis) ?

    Ist hier ein typischer Anwendungsfall für die Verwendung von Await.result.

    Können sagen, Sie haben ein Programm geschrieben, mit Haupt-thread und alle die Berechnung innerhalb des Haupt-thread asynchron ist. Nun, sobald Sie anfangen, die asynchrone Berechnung innerhalb des Haupt-thread. Einige muss man halt den main-thread aus bestehenden, bis die asynchrone Berechnung abgeschlossen ist, wenn nicht wird das Programm nicht ausgeführt, und Sie können nicht sehen, das Ergebnis der asynchronen Berechnung.

    Wenn eine Anwendung mit der Ausführung beginnt, gibt es eine nicht-daemon-thread, deren Aufgabe es ist, zum ausführen von main(). Die JVM nicht beendet werden, selbst, bis und es sei denn, nicht-daemon-threads beendet sind.

    object Main {
     def main(args: Array[String]): Unit = {
      import scala.concurrent.Future
      import scala.concurrent.duration._
    
      val f = Future { //do something }
      //stop main thread till f completes
      Await.result(f, 10 seconds)
     }
    }

    Zukunft verwendet daemon-threads für die Ausführung. Also daemon-threads kann nicht aufhören, die JVM aus Herunterfahren. Also die JVM heruntergefahren wird, auch wenn nicht-daemon-threads ausgeführt werden.

    Im obigen Fall gibt es keine andere Möglichkeit gibt, erwarten die Beendigung (Blockierung) der Haupt-thread, bis die Berechnung f abgeschlossen, wenn nicht der Haupt-thread beendet wird, und die Berechnung beendet.

    In den meisten Fällen, Sie brauchen nicht zu verwenden Await.result und einfache Future Zusammensetzung mit map und flatMap würde ausreichen.

    Risiken der Nutzung Erwarten.Ergebnis (In der Regel alle blockieren-code)

    Läuft die threads in Ereignis-basierten Modell

    In Ereignis-basierten Modell werden Sie schnell genügend threads, wenn Sie die Blockierung code, der braucht lange Zeit, um zurückzukehren. In playframework Sperre nennen könnte die Abnahme der Leistung der Anwendung und die app wird tot wird langsam, wie es läuft out-of-threads.

    Der Speicher im nicht-Ereignis-basierte Modelle

    Im thread-per-request-Modelle. Wenn Sie blockierende Aufrufe, die lange Zeit zu beenden/zurück.

    Fall 1: Wenn Sie fixed thread pool dann Anwendung könnten die threads.

    Fall 2: Wenn Sie dynamisch wachsenden thread pool dann Ihre Anwendung wird darunter leiden, zu viel Kontext-switching-overhead und auch run out of memory, weil zu viele gesperrte threads in Erinnerung.

    In allen Fällen keine sinnvolle Arbeit getan wird, erwarten für das warten auf IO oder eine andere Veranstaltung.

    • Danke. Gibt es eine alternative mit Zukunft in der Scala, das ist sicherer und weniger Risiko für die Leistung (wenn wir Erwarten)?
    • NÖ, Sie haben zu gehen mit warten in diesem Fall. Sie können erwarten, für die Aufbewahrung Haupt-thread am Leben für futures abzuschließen
    • ein anderer Weg ist non-deamon threads für futures, aber es ist eine schlechte Praxis und sollte nie verwendet werden.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.