This article investigates a production issue on Java 21 where virtual threads cause Tomcat to stop processing requests, closeWait sockets to accumulate, and locks to deadlock, detailing the diagnostics, thread‑dump analysis, lock inspection, and the eventual conclusions about virtual‑thread behavior.
This article explains what Java virtual threads are, compares them with ordinary platform threads, shows how to enable them in SpringBoot, and presents performance benchmarks that reveal virtual threads can be up to two hundred times faster for I/O‑bound workloads.
JEP 453 integrates StructuredTaskScope into Java 21, offering a preview API that replaces Future with Subtask, enabling lightweight virtual‑thread based concurrent tasks, such as fetching data from multiple servers and automatically cancelling slower calls, while simplifying error handling and improving observability.
Learn how to enable and test Java 21 virtual threads in Spring Boot 3.2.5, compare their throughput against platform threads with JMeter, and explore performance limits through sample code and benchmarks, revealing when virtual threads excel and their constraints for CPU‑bound tasks.
This article explores Java virtual threads introduced in JDK 21, detailing their architecture, implementation, practical usage with Thread and Executors APIs, performance comparisons against platform threads, best‑practice guidelines, and benchmark results demonstrating superior throughput for high‑concurrency server applications.
Java virtual threads, introduced in JDK 21, decouple Java threads from OS threads by using continuations and a ForkJoinPool scheduler, allowing millions of cheap, blocking‑friendly threads that boost throughput and simplify concurrent code compared to traditional platform threads or reactive frameworks, as demonstrated by performance benchmarks.
The article explains Java's virtual threads introduced in Java 19, compares them with traditional threads, and demonstrates how to configure Spring Boot to use virtual threads, including code samples and performance benchmarks that show dramatic latency reductions in both async services and HTTP requests.
This article explains how Spring Boot 3.2 can be accelerated with Class Data Sharing, virtual threads, GraalVM native images, ProblemDetail error handling, and new observability features, providing practical commands and code examples for faster startup, lower memory usage, and richer monitoring.
This article explains Java virtual threads introduced in Java 19, compares them with traditional OS threads, shows how to enable them in Spring Boot, and presents performance benchmarks that demonstrate dramatic latency reductions for I/O‑bound workloads.
This article explains what Java virtual threads are, compares them with traditional threads, shows how to enable them in SpringBoot with configuration and code examples, and presents performance tests that demonstrate dramatic speed improvements for IO‑bound workloads.
This article explains Java virtual threads, compares them with traditional OS threads, shows how to enable them in SpringBoot 3, and presents performance benchmarks demonstrating up to 200‑fold speed improvements for I/O‑bound workloads.
This article explains Java virtual threads, contrasting them with platform threads, and shows how to create, schedule, and use them effectively with Thread.Builder and Executors to achieve high‑throughput, low‑latency server applications while avoiding common pitfalls like pooling and pinning.
This article explains what Java virtual threads are, how they differ from regular threads, shows how to enable them in SpringBoot 3.1.2 with Java 20, and presents performance benchmarks that demonstrate up to 200‑fold speed improvements for IO‑bound workloads.
This guide explains how Spring Boot 3.2+ leverages JDK 21 virtual threads, demonstrates common pitfalls in non‑web applications—especially daemon thread termination—and shows how to enable keep‑alive configuration to ensure your tasks keep running, complete with code examples and performance insights.
This article examines the concept of streams, compares existing Java stream libraries, introduces Java 22's Stream Gather API, and demonstrates how virtual threads simplify implementing advanced operators like mapConcurrent, while outlining design goals, code examples, and future extensions.
The article explains Java 22’s new Stream Gather API, which extends the traditional Stream model with custom Gatherers that can emit zero‑to‑many elements, enabling stateful, parallel operations such as a concurrency‑controlled mapConcurrent operator built on virtual threads, and compares it to Reactor‑core and Pekko‑Stream.
This article evaluates the performance of Spring Boot 3.2's virtual threads versus traditional platform threads when serving static files, using a MacBook Pro M2, Bombardier load testing, and detailed latency and throughput metrics across multiple concurrency levels.
This article explains how to manage the throughput of Java 21 virtual threads by using Executors to create them and applying java.util.concurrent.Semaphore to limit concurrent execution, ensuring efficient and safe concurrency without pooling virtual threads.
This article compares Spring Boot 3.2's virtual‑thread support with traditional Tomcat thread pools and reactive WebFlux, showing configuration steps, code examples, JMeter load‑test results, and database access benchmarks to illustrate throughput, CPU and memory impacts.
This article examines a performance comparison of Spring Boot applications using physical threads, Java virtual threads, and WebFlux for JWT verification with MySQL, detailing test setup, code examples, benchmark results across various concurrency levels, and concluding that virtual threads perform worst due to MySQL driver incompatibility.
This guide walks through Spring 6’s new capabilities—including Java 17 baseline, Jakarta namespace migration, HTTP interface proxies with @HttpExchange, WebClient integration via JDK HttpClient, internationalized ProblemDetail handling, the RestClient API, and executing asynchronous tasks on virtual threads—all demonstrated with concise code examples.
This article evaluates the performance of Spring Boot 3.2's virtual threads when serving static files, comparing them with traditional platform threads across various concurrency levels, and concludes that platform threads slightly outperform virtual threads in this I/O‑bound scenario while suggesting better use cases for database‑driven workloads.
This article introduces a Java virtual‑thread based asynchronous task framework, detailing its design constraints, a thread‑safe task queue, daemon thread management, and overloaded execute methods for Runnable and Groovy Closure, along with code examples and performance testing considerations.
Spring Boot 3.2 now fully supports Java 21, Project Loom virtual threads, and GraalVM native images, and this guide walks through installing Java 21‑GraalVM, configuring virtual threads, building sample controllers, async and scheduled tasks, and creating a native executable to achieve faster startup and lower memory usage.
This article demonstrates how to use Spring Boot 3.2 with Java 21, enabling virtual threads and GraalVM native images, providing step‑by‑step setup, configuration, and sample code for controllers, async tasks, and scheduled jobs, and discusses performance benefits and considerations.
The article recaps a Scala & Java meetup where experts discussed the challenges of traditional Java threading, introduced JDK virtual threads as a low‑overhead concurrency solution, examined their benefits and limitations, and explored the impact of virtual threads on Scala and reactive programming.
Java’s traditional synchronous blocking model wastes thread resources during I/O, leading to scalability limits, while asynchronous, reactive, and especially Java 21’s virtual threads offer non‑blocking execution paths that improve performance and simplify development without complex reactive pipelines.
The article recaps a Scala & Java meetup where experts discussed Java virtual threads as a breakthrough for JDK concurrency, examined their advantages over traditional threads, addressed limitations, explored their impact on Scala and other JVM languages, and included audience Q&A and community announcements.
This article demonstrates how Spring Boot 3.2 fully supports Java 21, Project Loom virtual threads, and GraalVM native images, providing step‑by‑step instructions, configuration details, and runnable code examples that showcase building, running, and profiling a Spring Boot application with these modern technologies.
This article explains why Java 21 deprecates the Windows 32‑bit x86 port and dynamic agent loading, outlines the technical reasons, shows the required configuration flags and code examples, and discusses the security and maintenance implications of using deprecated APIs.
This article demonstrates how Spring Boot 3.2 fully supports Java 21, Project Loom virtual threads, and GraalVM native images, guiding you through installation, configuration, sample code, and performance benefits of running a Spring application on virtual threads and native compilation.
Spring Boot 3.2, released shortly after Java 21, brings a host of enhancements such as virtual thread support, CRaC checkpoint restore, SSL bundle reloading, improved observability, new RestClient and JdbcClient, Jetty 12, Pulsar, Kafka and RabbitMQ SSL, redesigned nested JAR handling, Docker image build upgrades, and a comprehensive video walkthrough by Josh Long.
The article explains why Java 21 deprecates the Windows 32‑bit x86 port and dynamic agent loading, describes the technical reasons, shows the new configuration options and related warnings, and discusses the impact on virtual threads and best practices for avoiding deprecated APIs.
This article demonstrates how to integrate Project Loom virtual threads into a Spring Boot application, configure Maven and Tomcat, implement REST endpoints, run JMeter load tests, and compare response times between traditional and virtual threads to showcase significant performance improvements.
Spring Boot 3.2 introduces Java 21 virtual thread support, SSL hot‑reload for embedded servers, GraalVM native image improvements, and a preview of Spring AI, marking a major evolution for Java backend development and performance optimization.
This article introduces Java virtual threads, compares them with traditional platform threads, demonstrates multiple creation and execution patterns, showcases performance benefits through code examples, and explains structured concurrency as a preview feature for building high‑throughput, scalable backend applications.
This article explains JDK21's new virtual threads, compares them with traditional thread pools through a 10,000‑thread benchmark, shows over 20‑fold performance gains, and provides practical code examples and configuration tips for Java developers.
This article introduces Java 21’s major enhancements—including lightweight virtual threads and generational ZGC—provides code samples for creating virtual threads and enabling ZGC, demonstrates a Spring Boot 3.x application using record patterns, and explains how to monitor Java 21 services with Alibaba Cloud ARMS on ACK.
This article explores JDK 21's major features including virtual threads, generational ZGC, and new APIs, comparing their performance with traditional threading models and demonstrating practical implementations in Spring Boot.
Java 21, released on September 19 as a long‑term‑support release with eight years of Oracle support, introduces fifteen JEPs—including preview string templates, record patterns, switch pattern matching, virtual threads, scoped values, structured concurrency, foreign function & memory APIs, and a new sequenced‑collection interface—along with numerous performance, security, and deprecation updates, all illustrated with code examples.
This article explains Java 21's virtual threads, their lightweight nature, and provides step‑by‑step code examples for creating and managing them via static builders, ExecutorService, and thread factories, helping developers improve concurrency and scalability in Java applications.
The new GraalVM for JDK 21 brings full virtual‑thread support, native‑image capabilities without preview flags, performance improvements, early Java Vector API optimizations, and a high‑performance runtime for Java and other languages, with download links and additional resources for developers.
This article explains Java virtual threads introduced in Java 19, describing how they are implemented with Continuation Passing Style, how to create them using VirtualThreadFactory, their benefits and drawbacks, and the performance impact they may have on different types of applications.
This tutorial shows how to activate Java 21 virtual threads in Spring Boot 3.1 (and earlier versions), provides full configuration code for Tomcat, Undertow and Spring async, and demonstrates a performance test where concurrency gains reduce total execution time by over five times.
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.