Scala for Backend Engineering & Functional Programming · Lektion

Einführung in Futures und Promises

Verstehen Sie die grundlegenden Konzepte von `Future` für asynchrone Ergebnisse und `Promise` zu deren Fertigstellung.

Einführung in Futures und Promises ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 1 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Scala for Backend Engineering & Functional Programming-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 3 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

Async Code: Why It Matters

In programming, tasks can run synchronously (one after another) or asynchronously (tasks can start without waiting for previous ones to finish).

Asynchronous programming is crucial for building responsive applications that don't freeze while waiting for slow operations like network requests or database queries.

The Problem with Blocking Calls

Imagine your program needs to fetch data from the internet. If this operation is blocking, your program will pause and do nothing else until the data arrives.

This can lead to a 'frozen' user interface or inefficient server-side applications. We need a way to perform these tasks in the background without halting the main flow.

Introducing Scala Futures

Scala's Future is a powerful tool for asynchronous programming. It represents a value that may not yet be available, but will be at some point in the future.

Think of it like ordering a coffee: you get a receipt (the Future) and can do other things while your coffee is being made.
When the coffee is ready, the receipt is 'completed' with your drink (the result).

Creating Your First Future

You can create a Future by wrapping a computation in Future { ... }. This computation will run on a separate thread.

An ExecutionContext is needed to schedule these tasks. We'll use a global one for simplicity.

import scala.concurrent.{Future, ExecutionContext}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.util.{Failure, Success}

object Main extends App {
  println("Starting computation...")

  val f: Future[Int] = Future {
    Thread.sleep(1000) // Simulate a long operation
    42
  }

  f.onComplete {
    case Success(value) => println(s"Result: $value")
    case Failure(e) => println(s"Error: ${e.getMessage}")
  }

  println("Computation started, continuing...")
  // Keep main thread alive for a bit to see Future's result
  Thread.sleep(2000)
}

Understanding ExecutionContext

An ExecutionContext is essentially a thread pool where asynchronous computations are run.

It manages how and when tasks are executed.
For quick examples, scala.concurrent.ExecutionContext.Implicits.global is often used, providing a default thread pool.
In real applications, you might configure specific thread pools for better control over resource usage.

Handling Future Results: onComplete

The onComplete method is used to define what happens when a Future finishes, whether it succeeds or fails.

It takes a function that operates on a scala.util.Try, which can be either Success(value) or Failure(exception).

import scala.concurrent.{Future, ExecutionContext}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.util.{Failure, Success}

object Main extends App {
  val futureSuccess = Future { 10 / 2 }
  val futureFailure = Future { 10 / 0 }

  futureSuccess.onComplete {
    case Success(result) => println(s"Success: $result")
    case Failure(e) => println(s"Error: ${e.getMessage}")
  }

  futureFailure.onComplete {
    case Success(result) => println(s"Success: $result")
    case Failure(e) => println(s"Error: ${e.getMessage}")
  }

  Thread.sleep(100) // Allow Futures to complete and print
}

Simplified Handlers: Success/Failure

For simpler cases, you can use onSuccess and onFailure to handle only successful results or only errors, respectively.

onSuccess takes a function for the successful value.
onFailure takes a function for the exception.
These are convenience methods built on top of onComplete.

import scala.concurrent.{Future, ExecutionContext}
import scala.concurrent.ExecutionContext.Implicits.global

object Main extends App {
  val futureValue = Future { "Hello, Scala!" }

  futureValue.onSuccess { case msg => println(s"Got message: $msg") }
  futureValue.onFailure { case e => println(s"Oops, an error: ${e.getMessage}") }

  val futureError = Future { throw new RuntimeException("Something broke!") }

  futureError.onSuccess { case msg => println(s"Got message: $msg") }
  futureError.onFailure { case e => println(s"Oops, an error: ${e.getMessage}") }

  Thread.sleep(100) // Allow Futures to complete and print
}

What is a Scala Promise?

While a Future is a read-only placeholder for a result, a Promise is a write-once container that can be completed with a value or an exception.

A Promise is used to complete a Future.
You create a Promise, get its associated Future, and then complete the Promise when the result is ready.

Fulfilling a Promise

You can complete a Promise using its success() or failure() methods. Once a Promise is completed, its associated Future will also complete.

Attempting to complete a Promise more than once will result in an error.

import scala.concurrent.{Future, Promise, ExecutionContext}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.util.{Failure, Success}

object Main extends App {
  val p = Promise[String]() // Create a Promise that will hold a String
  val f: Future[String] = p.future // Get the Future associated with the Promise

  f.onComplete {
    case Success(value) => println(s"Future completed with: '$value'")
    case Failure(e) => println(s"Future failed with: ${e.getMessage}")
  }

  // Simulate an async operation completing the promise
  Future {
    Thread.sleep(500)
    p.success("Data fetched successfully!") // Complete the Promise
  }

  println("Promise created, waiting for completion...")
  Thread.sleep(1000) // Keep main thread alive to see Future's result
}

Futures and Promises Together

Future and Promise often work hand-in-hand. A common pattern is to use a Promise when you need to manually control the completion of a Future, perhaps from an external system or an older, callback-based API.

This allows you to wrap non-Future-based asynchronous operations into the Future model, making them compatible with Future-based code.

import scala.concurrent.{Future, Promise, ExecutionContext}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.util.{Failure, Success}

object Main extends App {
  def performLongTask(data: String): Future[String] = {
    val p = Promise[String]()
    // Simulate an external system or callback-based API
    Future {
      Thread.sleep(700)
      if (data == "fail") p.failure(new Exception("Task failed!"))
      else p.success(s"Processed: $data")
    }
    p.future // Return the Future that will be completed by the Promise
  }

  val task1 = performLongTask("input data")
  task1.onComplete { case Success(res) => println(s"Task 1: $res") case Failure(e) => println(s"Task 1: ${e.getMessage}") }

  val task2 = performLongTask("fail")
  task2.onComplete { case Success(res) => println(s"Task 2: $res") case Failure(e) => println(s"Task 2: ${e.getMessage}") }

  Thread.sleep(1500) // Keep main thread alive for results
}

Quick Check: Future vs. Promise

Which of the following statements correctly describe the roles of Future and Promise in Scala?

Recap: Futures & Promises

Great job! In this lesson, you've learned the fundamentals of asynchronous programming in Scala:

Future: A placeholder for a result that will eventually be available.
Promise: A write-once container used to manually complete a Future.
ExecutionContext: Schedules the execution of asynchronous tasks.
How to handle Future results using onComplete, onSuccess, and onFailure.

These concepts are building blocks for more complex asynchronous patterns!

Häufig gestellte Fragen

Ist die Lektion „Einführung in Futures und Promises“ kostenlos?

Ja — der vollständige Text von „Einführung in Futures und Promises“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Scala for Backend Engineering & Functional Programming-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 3 Lektionen.

Was lerne ich in „Einführung in Futures und Promises“?

Verstehen Sie die grundlegenden Konzepte von `Future` für asynchrone Ergebnisse und `Promise` zu deren Fertigstellung. Du übst Scala for Backend Engineering & Functional Programming mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Scala for Backend Engineering & Functional Programming zu starten?

Keine Vorkenntnisse erforderlich. Scala for Backend Engineering & Functional Programming auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 3.

Wie lange dauert die Lektion „Einführung in Futures und Promises“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Scala for Backend Engineering & Functional Programming-Lektion Code schreiben und ausführen?

Ja. Jede Scala for Backend Engineering & Functional Programming-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Scala for Backend Engineering & Functional Programming