JDK 27 reached general availability on September 15, 2026. It's a short-term release — nine JEPs, four of them preview features and one incubator — sitting between Java 25 LTS and the next LTS, Java 29, due in September 2027. Most release round-ups list the JEPs. This post answers the question a Spring Boot team actually has: what changes under my running services, and what do I need to check?

9
JEPs in
JDK 27
3
Change your runtime
automatically
29
Next LTS
(Sept 2027)

The three changes that land on you without asking

Preview features need --enable-preview, so they can't surprise you. These can — they apply the moment you point your build or container image at JDK 27.

1. G1 is now the default garbage collector everywhere (JEP 523). Since JDK 9, G1 has been the default on "server-class" machines, but on small environments — one CPU or under about 2 GB of memory — HotSpot quietly fell back to the Serial collector. Many Kubernetes pods with a CPU limit of 1 have been running Serial GC for years without anyone noticing. On JDK 27, they'll get G1.

2. Compact object headers are on by default (JEP 534). Every Java object carries a header. Project Lilliput shrinks it from 96 bits to 64. For a typical Spring Boot service — millions of small DTOs, entities and collections — that means a smaller heap and better cache behaviour, with no code changes. Early measurements reported in the community put heap savings in the 10–20% range for object-heavy workloads.

3. Post-quantum hybrid key exchange for TLS 1.3 (JEP 527). Applications using the standard javax.net.ssl APIs get hybrid key exchange — a quantum-resistant algorithm combined with a classical one — by default. For most services this is invisible. It's worth a test if you talk to old load balancers, HSMs or partner endpoints with unusual TLS stacks.

Think of it like this
Upgrading the JDK is like moving your app into a newer building. The furniture (your code) is the same, but the plumbing and wiring — garbage collector, object layout, TLS — may be different. Most of the time it's simply better. Occasionally a tap turns the other way, and you want to find that in staging, not production.

How to check what your containers are actually running

Before and after the upgrade, ask the JVM inside the container what it chose. This one command prints the selected collector and heap sizing flags:

inside your container
# Prints the flags the JVM picked, including -XX:+UseG1GC or -XX:+UseSerialGC java -XX:+PrintCommandLineFlags -version

If a small, latency-insensitive batch pod was deliberately tuned for Serial GC, keep that behaviour explicit rather than relying on the old default:

deployment.yaml (excerpt)
env: - name: JAVA_TOOL_OPTIONS value: "-XX:+UseSerialGC -XX:MaxRAMPercentage=75"

The preview and incubator features worth trying

Five JEPs are re-submitted previews or incubators: Lazy Constants, Structured Concurrency and PEM Encodings (with minor changes), and Primitive Types in Patterns (JEP 532, fifth preview) and the Vector API (unchanged). Structured Concurrency is the one to watch for backend developers: it treats a group of concurrent sub-tasks — say, calling three downstream services for one request — as a single unit that succeeds, fails or is cancelled together. Try it in a branch; don't ship preview APIs to production, because they can still change.

JDK 27 also adds JFR redaction for sensitive values in environment variables, system properties and program arguments — useful if you ship Flight Recorder files to vendors or support teams. And looking ahead, the first preview of Project Valhalla's value classes has already been integrated into JDK 28; I explain what that means in my Valhalla deep dive.

Should you move production to Java 27?
For most teams, no — stay on Java 25 LTS and plan for Java 29. A non-LTS JDK means repeating the upgrade exercise every six months. What you should do is add a JDK 27 job to CI now. It surfaces breaking changes early, gives you the GC and memory numbers for your real workload, and turns the Java 29 upgrade next year into a formality. Before running Spring Boot on a new JDK in production, confirm it's in Spring Boot's supported Java range for your version.

Frequently asked questions

Is Java 27 an LTS release?

No. Java 27 is a short-term release. The current LTS is Java 25 (September 2025), and the next LTS, Java 29, is expected in September 2027.

What is the default garbage collector in Java 27?

G1. JEP 523 makes G1 the default in all environments, including small containers and single-CPU machines that previously defaulted to the Serial collector.

Do I need to change code to upgrade to Java 27?

Usually not. The headline changes — G1 by default, compact object headers and post-quantum TLS key exchange — apply automatically. Check containers that relied on Serial GC and any integrations with unusual TLS stacks.

JDK 27 shipped September 15, 2026 with nine JEPs; it is not an LTS.
G1 everywhere changes GC behaviour for small pods that silently ran Serial GC.
Compact object headers shrink heap usage with no code changes.
Run JDK 27 in CI, keep production on Java 25 LTS, and plan for Java 29.