Zum Inhalt springen

atra.consulting: „Wie kann ich Java schneller starten – und wann lohnt sich das?“

Veröffentlicht am · Aktualisiert am · 6 Min. Lesezeit
atra.consulting-Logo

Teilen

Zusammenfassung

Ein schnellerer Java-Start kann sich lohnen, wenn Sie Serverless Computing (etwa AWS Lambda) einsetzen, viele Services betreiben oder eine sehr hohe Verfügbarkeit brauchen. Java braucht von Haus aus mehr Zeit, mehr CPU und mehr Speicher zum Starten.

Vier Wege führen zu einem schnelleren Java-Start:

  • Spring-Boot-Tuning
  • Class Data Sharing (CDS) und Project Leyden
  • Project CRaC
  • GraalVM Native Image

Warum ich zu diesem Schluss komme, zeigen meine Folien weiter unten.

Rahmendaten

Ort

Ich hielt den Vortrag in der Stuttgarter Niederlassung meines Auftraggebers atra.consulting.

Vortrag

Ich hielt den Vortrag am 4. November 2025 um 15:00 Uhr.

Abstract

So können Java-Anwendungen schneller starten – sortiert nach aufsteigendem Geschwindigkeitsgewinn: Framework-Tuning, Class Data Sharing (CDS), Project Leyden/JEP 483 (ab Java 24), CRaC und GraalVM Native Image. Aber: Je schneller der Start, desto größer sind Aufwand und Beschränkungen. Das kann sich lohnen, weil die Uptime der Anwendung steigt, die Anzahl der Standby-Instanzen sinkt oder Serverless Computing billiger wird.

Der Vortrag demonstriert mit einem Spring-Boot-Beispiel-Projekt alle Optionen, erklärt Vor- und Nachteile und gibt Hinweise für die Wirtschaftlichkeitsberechnung.

Warum ich mich damit auskenne

Im Frühjahr 2022 war ich Redakteur einer sechsteiligen Artikelserie über natives Java auf InfoQ. Ich habe selbst mehrere Artikel über Project Leyden, CRaC und GraalVM Native Image geschrieben und auch Vorträge dazu gehalten.

Folien

Die Folien stehen als PDF zur Verfügung:

Folien herunterladen (PDF)

Diese Folien enthalten mehr Inhalt und mehr Text als die Folien, mit denen ich auf der Bühne stehe — dafür sind sie mit 0,4 MB angenehm klein. Außerdem gibt es eine Keynote-Version mit weniger Text, Animationen und Sprechernotizen; die steht hier allerdings nicht zum Download bereit.

Benchmark-Repository

Der gesamte Code für diese Benchmarks liegt in einem öffentlichen GitHub-Repository: ksilz/spring-petclinic.

Verwendung

Das Repo ist ein Fork des offiziellen Spring-PetClinic-Projekts. Ich habe Shell-Skripte zum Bauen (compile-and-run.sh) und für Trainings-/Benchmark-Läufe (benchmark.sh) ergänzt, dazu eine kleine Bibliothek für CRaC. Die Skripte sind nur unter Linux und macOS getestet.

Benchmarks starten Sie mit ./compile-and-run.sh [Szenario]:

  • baseline: reines Spring Boot, Option 0. Braucht JDK 25.
  • tuning: Spring-Boot-Tuning, Option 1. Braucht JDK 25.
  • cds: Class Data Sharing, Teil von Option 2. Braucht JDK 25.
  • leyden: Project Leyden, Teil von Option 2. Braucht JDK 25.
  • crac: Project CRaC, Option 3. Braucht JDK 25 von Azul mit CRaC-Unterstützung, nur unter Linux.
  • graalvm: GraalVM Native Image, Option 4. Braucht das GraalVM Oracle JDK 25 und viel Speicher — 16 GB reichten nicht aus.

Startzeit und Speicherverbrauch messen

Das Benchmark-Skript führt drei Aufwärmläufe durch, danach sieben Benchmark-Läufe. Den schnellsten und den langsamsten Lauf verwirft es, aus den verbleibenden fünf bildet es den Durchschnitt.

Für die Startzeit sucht das Skript bei CRaC nach restored JVM running for X ms im Spring-Boot-Log, bei allen anderen Szenarien nach Started PetClinicApplication in X.XXX seconds.

Den Speicherverbrauch misst es über /usr/bin/time: Unter macOS liest es „peak memory footprint“ aus /usr/bin/time -l, unter Linux „Maximum resident set size“ aus /usr/bin/time -v. Intern rechnet das Skript beides in KB um und zeigt das Ergebnis in MB an.

Hinweise

Ich habe die Skripte zunächst mit der KI-IDE Cursor erstellt und dann mit Claude Code überarbeitet — das erklärt vielleicht die ein oder andere Ecke und Kante.

Ursprünglich waren auch Maven-Build-Befehle geplant. Das Grundgerüst dafür steckt noch im Repo, funktioniert aber nicht.

Weitere Informationen zum Vortrag

Die sechsteilige Artikelserie über natives Java auf InfoQ aus dem Jahr 2022 ist die Grundlage für vieles in diesem Vortrag — ich habe sie redigiert, nicht selbst geschrieben. Weitere Artikel und News von mir bei InfoQ finden Sie auf meinem Profil.

Lohnt sich das?

Wann lohnt sich schnellerer Start?

AWS Lambda SnapStart zeigt, wo sich schneller Start unmittelbar auszahlt: Es senkt die Cold-Start-Latenz von Serverless-Funktionen. Am anderen Ende des Spektrums zeigt Apples Umstieg von Teilen seines Passwort-Systems von Java auf Swift, wie schwer die Kosten einer langsamer startenden Laufzeitumgebung wiegen können.

Eine beispielhafte Wirtschaftlichkeitsrechnung

Nehmen wir eine Microservice-Java-Anwendung auf Kubernetes, die durch den Umstieg auf GraalVM Native Image die Betriebskosten senken will. Die Idee: weniger Speicherverbrauch bedeutet mehr Pods pro Knoten — und damit weniger Server insgesamt.

Annahmen: Die Anwendung läuft auf Kubernetes unter Linux auf Amazon-EC2-T3.2XLarge-Servern (32 GB RAM, 8 CPUs) zu 280 EUR/Monat, macht 10.080 EUR über 36 Monate. Entwickler arbeiten unter macOS und debuggen Produktionsprobleme in Linux-Containern. Entwickler-/Admin-Zeit kostet 100 EUR/Stunde. Die Investition soll nach drei Jahren einen positiven ROI zeigen.

Personalkosten: eine einmalige Einführung (Build-/Deployment-Anpassungen, Schulung) mit 120 Stunden bzw. 12.000 EUR; laufende Wartung mit 4 Stunden pro Monat über 30 Monate, nochmals 120 Stunden bzw. 12.000 EUR; Upgrades alle sechs Monate (Spring Boot, GraalVM) mit je 16 Stunden, fünfmal, macht 80 Stunden bzw. 8.000 EUR; sowie Produktivitätsverlust durchs Debuggen nativer Executables in Produktion, 4 Stunden pro Monat über 35 Monate, macht 140 Stunden bzw. 14.000 EUR. Gesamte Personalkosten über drei Jahre: 46.000 EUR.

Betriebskosten: ein zusätzlicher EC2-T3.2XLarge-Build-Server, 10.080 EUR.

Gesamtkosten: 56.080 EUR.

Für einen positiven ROI muss GraalVM Native Image die Anzahl der EC2-T3.2XLarge-Server um mindestens sechs senken — sechs eingesparte Server bedeuten 60.480 EUR, also einen Netto-Gewinn von 4.400 EUR über drei Jahre.

Wie schneller?

Spring-Boot-Tuning

Zwei Bausteine leisten hier den Löwenanteil: Spring AOT und die JAR-Extraktion, beide gut beschrieben in diesem Baeldung-Artikel zu Spring-6-Ahead-of-Time-Optimierungen. Zum Zeitpunkt des Vortrags waren noch ein paar relevante Spring-Tickets offen: spring-cloud-stream#3118, spring-statemachine#1080 und spring-boot#37101.

Class Data Sharing und Project Leyden

Spring dokumentiert Class Data Sharing direkt in seinen How-to-Guides. Project Leyden hat seine ersten Bausteine mit JDK 24 ausgeliefert — ich habe darüber für InfoQ geschrieben. Die relevanten JEPs sind 483, 514, 515 und 516, dazu der Entwurf JEP 8335368.

Project CRaC

Project CRaC friert eine laufende JVM ein und stellt sie fast augenblicklich wieder her. Oracles Brian Goetz erklärt das in diesem Vortrag. Für die Nutzung brauchen Sie ein JDK mit CRaC-Unterstützung — sowohl Azuls OpenJDK-Build als auch BellSofts Liberica JDK bieten das an. Mehrere Frameworks unterstützen CRaC bereits von Haus aus: Spring Boot 3.2, Quarkus 2.10.0, Micronaut 3.7 und Helidon 4.2.

GraalVM Native Image

GraalVM Native Image kompiliert eine Java-Anwendung vorab in ein natives Executable; Spring Boot hat dafür eigene Dokumentation. Frameworks wie Spring Boot liefern die nötige Native-Image-Konfiguration für ihre Bibliotheken meist gleich mit (Spring Security, Spring Data und so weiter), und das GraalVM Reachability Metadata Repository ergänzt automatisch noch mehr davon. Manches geht mit Native Image schlicht nicht: neue Klassen oder Methoden zur Laufzeit erzeugen, neuen Bytecode ausführen, exotische Classloader-Tricks und Java-Agents (etwa für Observability). Einiges funktioniert nur teilweise: AWT und JavaFX (nicht unter macOS), JMX, viele Java-Flight-Recorder-Datenpunkte und manche Test-Frameworks. Und manches — Reflection, explizites Class Loading — braucht zusätzliche Konfiguration, um überhaupt zu funktionieren.