Zukünftige Sequenz in Scala

1. Führen Sie Futures sequentiell in Scala aus
2. Gleichzeitige/parallele Ausführung von Futures in Scala
3. Abschluss

In diesem Artikel werden wir etwas über futures in Scala lernen.

In Scala ist Zukunft ein Wert, der derzeit möglicherweise nicht verfügbar ist, aber in der Zukunft liegen wird.

Wenn wir Aufgaben gleichzeitig/parallel in Scala ausführen wollen, verwenden wir Futures. Obwohl wir einen nativen Java-thread verwenden könnten, wird Scala Future bevorzugt, da es viel einfacher zu schreiben ist.

Einfach ausgedrückt bietet Future einfache Möglichkeiten, einen Algorithmus/eine Anwendung gleichzeitig auszuführen. Wenn ein Future erstellt wird, beginnt es gleichzeitig zu laufen und liefert an einem bestimmten Punkt Ergebnisse, an einem bestimmten Punkt erhalten wir die Ergebnisse.

Führen Sie Futures sequentiell in Scala aus

Wenn futures beginnen, sequentiell ausgeführt zu werden, handelt es sich um einen sequentiellen Lauf. Wir müssen ExecutionContext importieren, der den Thread-Pool verwaltet; ohne sie läuft die Zukunft nicht.

Schauen wir uns ein Beispiel an, um es besser zu verstehen.

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future

object Example extends App {

  def task(n: Int) = Future
  {
    Thread.sleep(1000)
    println(n)  //to observe the output
    n + 1
  }

//running in a sequential way
  val temp = for {
    t1 <- task(1)
    t2 <- task(t1)
    t3 <- task(t2)
    t4 <- task(t3)
    t5 <- task(t4)
  } yield List(t1,t2,t3,t4,t5)
  temp.map(x => println(s"Completed. ${x.size} tasks were executed"))
  Thread.sleep(5000) //so that the main thread doesn't quit quickly
}

Wenn der Code ausgeführt wird, sehen wir, dass unsere 5 Aufgaben in sequentieller Reihenfolge nacheinander ausgeführt werden.

Gleichzeitige/parallele Ausführung von Futures in Scala

Beispielcode:

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future

object Example extends App {

  def task(n: Int) = Future
  {
    Thread.sleep(1000)
    println(n)  //to observe the output
    n + 1
  }

  val temp = for {
    t1 <- task(1)
    t2 <- Future.sequence(List(task(t1), task(t1)))
    t3 <- task(t2.head)
    t4 <- Future.sequence(List(task(t3), task(t3)))
    t5 <- task(t4.head)
  } yield t2.size + t4.size
  temp.foreach(x => println(s"Done. $x task run in concurrent manner"))
  Thread.sleep(6000) // needed to prevent the main thread from quitting
  // too early
}

Im obigen Code haben wir die Future.sequence verwendet, die die Liste der Futures nimmt und sie in eine future of list umwandelt. Alle Tasks/Jobs, die wir gleichzeitig ausführen wollen, müssen als Liste übergeben werden.

Ausgang:

Wenn der obige Code ausgeführt wird, sehen wir, dass t2 und t4 parallel ausgeführt werden. Beachten Sie bei der Arbeit mit Parallelität, dass die Ausführung möglicherweise nicht immer parallel ist, da dies von der Verfügbarkeit der Threads abhängt.

Wenn nur wenige Threads vorhanden sind, werden nur wenige Jobs parallel ausgeführt, während andere darauf warten, dass die Threads freigegeben werden.

Abschluss

In diesem Tutorial haben wir verstanden, was Futures sind und wie sie beim gleichzeitigen Schreiben und Ausführen von Programmen nützlich sind.