Oracle's Java 21 release introduces virtual threads, record patterns, ordered collections and a preview FFM API, while Eclipse survey data shows rising Spring and Spring Boot usage and accelerating cloud‑native adoption among Java developers.
Java 21, the latest LTS release, introduces virtual threads, sequenced collections, record patterns, and other enhancements; the article explains these new features, guides developers on configuring IDEs and runtimes with Azul Zulu and IntelliJ IDEA, and resolves Lombok incompatibility by updating to version 1.18.30.
Java 21, the latest long‑term support release, brings 15 JEPs—including string templates, record patterns, virtual threads, and a foreign function API—along with extensive performance, security, and maintenance updates, while extending Java 11 support through 2032.
The article introduces the official General Availability release of JDK 21, explains version naming conventions such as Alpha, Beta, RC, GA and LTS, and details its fifteen new features—including Virtual Threads, preview language enhancements, generational ZGC, and the removal of Shenandoah—while showing how to enable them.
This article summarizes a performance comparison between Spring Boot applications using virtual threads and those built with Spring WebFlux, detailing the test scenario of JWT verification and MySQL queries, the environment, code implementations, benchmark results across various concurrency levels, and concluding that WebFlux outperforms virtual‑threaded Spring Boot.
This article explains the concept of threads in computer science, demonstrates how Java encapsulates threads with the Thread class, shows basic and multithreaded examples, introduces thread pools and their management, and details the new virtual thread model introduced by Project Loom for high‑throughput, low‑overhead concurrency.
This article explains Project Loom’s virtual threads, shows how to enable them in a Spring Boot 3.1 application with Java 20, provides code samples and performance test results that demonstrate dramatically higher throughput under high concurrency.
Learn how Project Loom’s virtual threads can replace heavyweight OS threads in Java Spring Boot applications, enabling one‑thread‑per‑request models, improving throughput under high concurrency, with step‑by‑step setup, code samples, and performance comparisons across 100‑, 300‑ and 500‑thread tests.
Apache Tomcat 10.1.10 has been released, bringing Jakarta EE 10 support, automatic migration of Java EE apps via the Jakarta EE Migration Tool, and notable updates such as virtual thread support, RFC‑9218 HTTP/2 priority, deprecation of xssProtectionEnabled, and an upgraded Tomcat Native 2.0.4 with OpenSSL 3.0.9.
The article examines Java's 27‑year history, comparing its performance, startup time, and memory usage against modern languages and cloud‑native demands, while detailing JDK feature releases, module system, garbage collectors, AOT compilation, virtual threads, value types, GraalVM, and emerging frameworks to assess Java's relevance today and tomorrow.
This article systematically traces the evolution of Java multithreading from the early native Thread model through the introduction of java.util.concurrent and synchronized optimizations to the modern virtual thread era, highlighting key concepts, milestones, and performance impacts.
JDK 20, a short‑term support release of Java, introduces seven JEPs—including Scoped Values, Record Patterns, Virtual Threads, Structured Concurrency, and the Vector API—along with numerous enhancements and bug fixes, while remaining production‑ready and paving the way for the upcoming JDK 21 LTS.
The article explains Java's new Virtual Thread (coroutine) feature, compares the traditional thread‑per‑request model with asynchronous and coroutine approaches, discusses Little's Law for scalability, and outlines the benefits and pitfalls of using coroutines in server‑side Java applications.
JDK 20, a short‑term support release, brings six months of maintenance and introduces seven JEPs—including Scoped Values, Record Patterns, Pattern Matching for switch, Foreign Function & Memory API, Virtual Threads, Structured Concurrency, and the Vector API—each at various incubation or preview stages, while preparing for the upcoming LTS JDK 21.
JDK 20, a short‑term support release, brings seven new JEPs—including Scoped Values, Record Patterns, and Virtual Threads—alongside numerous enhancements and bug fixes, positioning it for production use while previewing features that will shape the upcoming JDK 21 LTS.
This article chronicles the evolution of Java multithreading from early native threads through the introduction of the concurrency utilities, lock optimizations, the Fork/Join framework, CompletableFuture, reactive streams, and finally virtual threads in JDK 19, explaining each milestone, its motivations, and its impact on modern Java development.
Spring Framework 6.0 RC1 introduces Java 17+ requirement, migration to Jakarta EE 9+, AOT compilation support, virtual‑thread integration, and updated compatibility with Tomcat 10, Jetty 11, and Hibernate 6.1, while adding new HTTP client features and observability enhancements.
Spring Framework 6.0 RC1, requiring Java 17+, migrates to Jakarta EE 9+, introduces AOT compilation, native GraalVM support, virtual‑thread executor options, and new HTTP client features, while supporting the latest servlet containers and Hibernate ORM, with upcoming Spring Boot 3.0 releases.
Spring Framework 6.0 RC1 has been released, requiring Java 17+, migrating to Jakarta EE 9+ namespaces, supporting the latest web containers and Hibernate ORM, introducing AOT compilation, virtual‑thread executor support, new @HttpExchange client, RFC 7807 handling, Micrometer observability, and more.
Spring Framework 6.0 RC1, requiring Java 17+, migrates to Jakarta EE 9+, adds AOT compilation support, enables virtual‑thread execution via Project Loom, updates to modern containers like Tomcat 10 and Jetty 11, and introduces new features such as @HttpExchange client, RFC 7807 handling, and Micrometer observability.
This article introduces Java 19's virtual threads, compares their performance and scheduling with traditional platform threads and Go goroutines, provides practical code examples, benchmark results, and migration guidelines, and explains the underlying M:N scheduling mechanisms that make virtual threads more efficient for high‑concurrency, I/O‑bound workloads.
This article outlines the seven preview features introduced in JDK 19—including Record Patterns, Linux/RISC‑V port, Foreign Function & Memory API, Virtual Threads, Vector API, Switch Pattern Matching, and Structured Concurrency—while also summarizing the release timeline and noting the trend of fewer features per Java release.
Java virtual threads, introduced in JEP 425, provide a lightweight, low‑cost alternative to traditional platform threads, enabling massive concurrency without the overhead of OS threads, improving throughput for server‑side applications while preserving familiar APIs and enhancing observability.
This article explains Java's preview virtual threads (JEP 425), how they differ from traditional platform threads, demonstrates their superior scalability with code examples, and provides step‑by‑step instructions to enable them in the JDK.
