Scala: Nebenläufigkeit und Ökosystem

Kurz: def quadrat(n: Int): Future[Int] = Future { n * n }

Teil des Kurses Scala

Kapitel 7 von 8 im Kurs Scala (Abschnitt „Fortgeschritten“). Mit Fortschritt, Quiz und Zertifikat auf der Lernseite.

Futures

import scala.concurrent.{Future, Await}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration.*
 
def quadrat(n: Int): Future[Int] = Future { n * n }
 
@main def main(): Unit =
  val f = for
    a <- quadrat(3)
    b <- quadrat(4)
  yield a + b
  println(Await.result(f, 5.seconds))
 
  val viele = Future.sequence((1 to 5).map(quadrat))
  println(Await.result(viele, 5.seconds))
 
  val fehler = Future { 1 / 0 }.recover { case _: ArithmeticException => -1 }
  println(Await.result(fehler, 5.seconds))

Ausgabe:

25
Vector(1, 4, 9, 16, 25)
-1

Lazy, Streams und Views

val fib: LazyList[BigInt] = BigInt(0) #:: BigInt(1) #:: fib.zip(fib.tail).map(_ + _)
 
@main def main(): Unit =
  lazy val teuer = { println("berechne"); 42 }
  println("vorher")
  println(teuer)
  println(teuer)
  val s = LazyList.from(1).map(_ * 2).filter(_ % 3 == 0)
  println(s.take(4).toList)
  println((1 to 1000000).view.map(_ * 2).filter(_ % 7 == 0).take(3).toList)
  println(fib.take(12).toList)
  println(Iterator.iterate(1)(_ * 3).takeWhile(_ < 500).toList)

Ausgabe:

vorher
berechne
42
42
List(6, 12, 18, 24)
List(14, 28, 42)
List(0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89)
List(1, 3, 9, 27, 81, 243)

Ressourcen und Dateien

import scala.util.Using
import java.nio.file.{Files, Path}
 
@main def main(): Unit =
  val p = Files.createTempFile("scala", ".txt")
  Files.writeString(p, "eins\nzwei\ndrei\n")
  val zeilen = Using(scala.io.Source.fromFile(p.toFile))(_.getLines().toList).get
  println(zeilen)
  println(zeilen.map(_.length))
  Files.delete(p)
  println(Files.exists(p))

Ausgabe:

List(eins, zwei, drei)
List(4, 4, 4)
false

Ökosystem

Werkzeug	Zweck
scala-cli	Skripte und kleine Projekte ohne Konfiguration
sbt	Standard-Build-Tool mit Abhängigkeiten
mill	Schneller Alternativ-Build
Metals	Language Server für VS Code und andere Editoren
ScalaTest, MUnit	Tests
Cats, ZIO	Funktionale Effekt-Bibliotheken
Akka / Pekko	Actor-Modell
Spark	Verteilte Datenverarbeitung (Big Data)
Play, http4s	Webframeworks

Tipp

Mit scala-cli run datei.scala startest du ein Programm in Sekunden, mit //> using dep bindest du Bibliotheken ein.

//> using scala 3
//> using dep com.lihaoyi::os-lib:0.10.0
@main def hallo() = println(os.pwd)

Merke

• Future mit for, Await nur in Tests oder main
• lazy val, LazyList und view verzögern Berechnungen
• Using schließt Ressourcen sicher
• Build: sbt, scala-cli, mill; Editor: Metals

Übungsaufgabe

Lade drei Berechnungen parallel in Futures und fasse sie mit Future.sequence zusammen.

Quiz zur Selbstkontrolle

Wofür steht lazy val?

• Wert wird erst beim ersten Zugriff berechnet (richtig)
• Wert ist veränderlich
• Wert wird nie berechnet
• Wert ist privat

Was ist sbt?

• Das Standard-Build-Tool für Scala (richtig)
• Eine Datenbank
• Ein Editor
• Ein Testframework

Wofür wird Spark genutzt?

• Für verteilte Datenverarbeitung (richtig)
• Für Grafiken
• Für Spiele
• Für Mails

Weiter im Kurs

Zurück: Generics, Given und Typklassen

Weiter: Referenz

Alle Kapitel: Scala im Überblick