← Java

Java · 23 / 24

Virtual Threads, Abbruch und Ressourcenlimits

Du stoppst eine wartende Aufgabe und begrenzt den Zugriff auf eine knappe Ressource.

  • Groß
  • Anspruchsvoll
  • 90 min

Voraussetzungen: Interfaces und Komposition, Maven, Module und Ports/Adapters

In diesem Tutorial
  1. Den Fachvertrag lesen
  2. Die Umgebung isoliert starten
  3. Erfolg und Fehler prüfen
  4. Eine Regression sichtbar machen
  5. Den Vertrag erweitern
  6. Die Lösung und ihre Grenzen erklären
  7. Übung und Lösung
  8. Projektbezug und Quellen

Lernpaket herunterladen

Einrichtung und Prüfstand

JDK 21, Maven ab 3.9. Zusätzlich Python 3 für den gemeinsamen Prüfstart. Entpacke das Lernpaket in einen neuen Ordner und führe dort python3 run_checks.py aus. Das Skript kopiert die enthaltenen Dateien in einen temporären Lernordner. Dort prüft es zuerst das Beispiel und danach die mitgelieferte Lösung. Die Ausgangsdateien bleiben erhalten. Benötigte Pakete werden beim ersten Lauf aus dem Netz geladen.

Geprüft am 20.10.2026 unter Linux x86_64. Die Tests zählen gleichzeitig aktive Aufgaben und prüfen das Limit sowie Abbruch. Ein Interrupt ist eine Aufforderung. Nicht unterbrechbare Bibliotheksaufrufe brauchen zusätzlich eigene Timeouts.

Viele virtuelle Threads erzeugen keine unbegrenzten Datenbankverbindungen. Ein Semaphore begrenzt hier zwei gleichzeitige Ressourcennutzer. Die Freigabe liegt in finally. Ein zweiter Test unterbricht eine wartende Aufgabe kontrolliert. Der Code nutzt keine Preview-API und läuft mit Java 21.

Paketinhalt und einzelne Dateien

01Den Fachvertrag lesen

Virtuelle Threads erleichtern viele wartende Aufgaben. Sie vergrößern keine Datenbank und kein externes API-Limit. Ein Semaphore begrenzt deshalb den Eintritt in die knappe Ressource. finally muss die erworbene Freigabe auch bei Fehlern zurückgeben.

src/main/java/tutorial/BoundedWork.java · javaDatei öffnen
package tutorial;

import java.util.concurrent.*;

public class BoundedWork {

  private final Semaphore permits = new Semaphore(2);

  public void run(Callable<Void> work) throws Exception {
    permits.acquire();
    try {
      work.call();
    } finally {
      permits.release();
    }
  }

  public int available() {
    return permits.availablePermits();
  }
}

02Die Umgebung isoliert starten

Java 21 ist die festgelegte Sprachbasis. Maven löst die Abhängigkeiten aus der POM auf. Der Test verwendet eigene Daten. HTTP-Tests starten einen Server auf einem zufällig zugewiesenen lokalen Port.

pom.xml · xmlDatei öffnen
<project xmlns="http://maven.apache.org/POM/4.0.0">
<modelVersion>4.0.0</modelVersion>
<parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>4.1.0</version></parent>
<groupId>learning</groupId><artifactId>tutorial</artifactId><version>1.0</version>
<properties><java.version>21</java.version></properties>
<dependencies>
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency>

</dependencies>
<build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build>
</project>

03Erfolg und Fehler prüfen

Die Tests zählen gleichzeitig aktive Aufgaben und prüfen das Limit sowie Abbruch. Ein Interrupt ist eine Aufforderung. Nicht unterbrechbare Bibliotheksaufrufe brauchen zusätzlich eigene Timeouts.

src/test/java/tutorial/LessonTest.java · javaDatei öffnen
package tutorial;

import static org.junit.jupiter.api.Assertions.*;

import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
import org.junit.jupiter.api.Test;

class LessonTest {

  @Test
  void boundedAndReleased() throws Exception {
    var work = new BoundedWork();
    var active = new AtomicInteger();
    var maximum = new AtomicInteger();
    try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
      var tasks = new ArrayList<Future<?>>();
      for (int i = 0; i < 20; i++) tasks.add(
        executor.submit(() -> {
          try {
            work.run(() -> {
              int n = active.incrementAndGet();
              maximum.accumulateAndGet(n, Math::max);
              try {
                Thread.sleep(5);
              } finally {
                active.decrementAndGet();
              }
              return null;
            });
          } catch (Exception e) {
            throw new RuntimeException(e);
          }
        })
      );
      for (var task : tasks) task.get(5, TimeUnit.SECONDS);
    }
    assertTrue(maximum.get() <= 2);
    assertEquals(2, work.available());
  }

  @Test
  void cancellationStopsWaitingTask() throws Exception {
    var started = new CountDownLatch(1);
    var stopped = new CountDownLatch(1);
    try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
      var future = executor.submit(() -> {
        started.countDown();
        try {
          Thread.sleep(60000);
        } catch (InterruptedException e) {
          Thread.currentThread().interrupt();
        } finally {
          stopped.countDown();
        }
      });
      assertTrue(started.await(2, TimeUnit.SECONDS));
      assertTrue(future.cancel(true));
      assertTrue(stopped.await(2, TimeUnit.SECONDS));
    }
  }
}

Starten / prüfen

mvn test
Erwartetes Ergebnis

Die Tests zählen gleichzeitig aktive Aufgaben und prüfen das Limit sowie Abbruch. Ein Interrupt ist eine Aufforderung. Nicht unterbrechbare Bibliotheksaufrufe brauchen zusätzlich eigene Timeouts.

04Eine Regression sichtbar machen

Verändere eine fachliche Erwartung und starte den Test erneut. Maven muss einen Fehler melden. Ein übersprungener Datenbanktest ist kein Nachweis. Stelle anschließend die richtige Erwartung wieder her.

05Den Vertrag erweitern

Lasse die fachliche Arbeit eine Exception werfen und prüfe danach die verfügbaren Permits.

06Die Lösung und ihre Grenzen erklären

Auch nach einem Fehler müssen beide Permits verfügbar sein. Der Test schützt die finally-Grenze. Ein fehlender Freigabepfad kann sonst erst unter Last als scheinbarer Stillstand auffallen. Kopiere solution/LessonTest.java über die Testdatei und wiederhole denselben Prüfablauf.

Erwartetes Ergebnis

Alle Testfälle bestehen, einschließlich der zusätzlichen Lösungserwartung.

Deine Übung

Lasse die fachliche Arbeit eine Exception werfen und prüfe danach die verfügbaren Permits.

Lösung mit Erklärung anzeigen

Auch nach einem Fehler müssen beide Permits verfügbar sein. Der Test schützt die finally-Grenze. Ein fehlender Freigabepfad kann sonst erst unter Last als scheinbarer Stillstand auffallen.

solution/LessonTest.java · javaDatei öffnen
package tutorial;

import static org.junit.jupiter.api.Assertions.*;

import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
import org.junit.jupiter.api.Test;

class LessonTest {

  @Test
  void failureReleasesPermits() {
    var work = new BoundedWork();
    assertThrows(IllegalStateException.class, () ->
      work.run(() -> {
        throw new IllegalStateException("injected");
      })
    );
    assertEquals(2, work.available());
  }

  @Test
  void boundedAndReleased() throws Exception {
    var work = new BoundedWork();
    var active = new AtomicInteger();
    var maximum = new AtomicInteger();
    try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
      var tasks = new ArrayList<Future<?>>();
      for (int i = 0; i < 20; i++) tasks.add(
        executor.submit(() -> {
          try {
            work.run(() -> {
              int n = active.incrementAndGet();
              maximum.accumulateAndGet(n, Math::max);
              try {
                Thread.sleep(5);
              } finally {
                active.decrementAndGet();
              }
              return null;
            });
          } catch (Exception e) {
            throw new RuntimeException(e);
          }
        })
      );
      for (var task : tasks) task.get(5, TimeUnit.SECONDS);
    }
    assertTrue(maximum.get() <= 2);
    assertEquals(2, work.available());
  }

  @Test
  void cancellationStopsWaitingTask() throws Exception {
    var started = new CountDownLatch(1);
    var stopped = new CountDownLatch(1);
    try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
      var future = executor.submit(() -> {
        started.countDown();
        try {
          Thread.sleep(60000);
        } catch (InterruptedException e) {
          Thread.currentThread().interrupt();
        } finally {
          stopped.countDown();
        }
      });
      assertTrue(started.await(2, TimeUnit.SECONDS));
      assertTrue(future.cancel(true));
      assertTrue(stopped.await(2, TimeUnit.SECONDS));
    }
  }
}

Projektbezug und Quellen

Das eigenständige Lernprojekt vertieft ein Thema aus diesem Technologiebereich. Die Projektverweise zeigen einen festgehaltenen Quellstand als Architekturkontext. Sie sind kein Beleg dafür, dass jede hier neu eingeführte Bibliothek oder Funktion bereits in dieser App verwendet wird.