Tagged articles
Project Loom
19 articles · Page 1 of 1
This article explains Java's Structured Concurrency API (StructuredTaskScope) introduced in Project Loom, covering its core concepts, Joiner policies for failure handling, cancellation propagation via thread interruption, timeout configuration, ScopedValue for context propagation, JSON thread dump debugging, and API evolution across JDK 19-27.
CancellationJava ConcurrencyJoiner
0 likes · 28 min read

The article details a real-world migration from a fixed 200-thread pool to Java 21 virtual threads, showing how serial calls to three 1-second external services caused 50-second tail latencies under load, and how virtual threads eliminated queuing by decoupling waiting from expensive OS threads, while covering pinning risks, ThreadLocal pitfalls, and migration steps.
ConcurrencyJava 21Project Loom
0 likes · 21 min read

The article reviews the JVM series finale, explaining how GraalVM Native Image, Project Loom, Project Valhalla, and Project Panama each address Java’s historic shortcomings—startup latency, heavyweight threads, object overhead, and clumsy native interop—while weighing their trade‑offs and future impact.
GraalVMJVMJava performance
0 likes · 12 min read

Jackson replaced its ThreadLocal-based buffer recycling with a pluggable RecyclerPool abstraction, iterated through multiple default pool implementations including a flawed LockFreePool, removed the leaky LockFreePool in 3.x, and fixed a TOCTOU race in BufferRecycler using atomic updates.
Buffer PoolingConcurrencyJackson
0 likes · 10 min read


java1234Apr 16, 2026 · Backend Development
The article explains why traditional platform threads are costly, defines Java virtual threads as lightweight JVM‑managed threads that unmount on blocking, compares their performance and limits to platform threads, outlines suitable and unsuitable use cases, provides starter code and best‑practice patterns, and offers a detailed production‑ready checklist to avoid common pitfalls such as pinning, ThreadLocal misuse, and blocking I/O.
ConcurrencyJavaProject Loom
0 likes · 16 min read

The article examines Project Loom's virtual threads, compares them with reactive streams, explores their underlying mechanisms, presents a direct‑style flow library (Jox) that combines both paradigms, and evaluates performance, backpressure, and error handling in Java concurrency.
ConcurrencyJavaJox
0 likes · 22 min read

The article explains why traditional OS‑based thread pools choke under 100,000 concurrent Java requests, introduces Java 21's Virtual Threads from Project Loom, shows their low‑memory, high‑throughput characteristics, provides Spring Boot configuration and code samples, and warns about synchronization, ThreadLocal and CPU‑bound pitfalls.
ConcurrencyI/OJava
0 likes · 10 min read

The article outlines twelve concrete shifts—cloud‑native defaults, Project Loom virtual threads, selective reactive use, AI‑assisted coding, API‑first design, built‑in observability, modular monoliths, security‑by‑design, native images, confidence‑driven testing, DDD revival, and a move from code writing to system judgment—that will define Java backend engineering by 2026.
AI codingJavaNative Image
0 likes · 8 min read


21CTOJan 18, 2026 · Fundamentals
Oracle’s 2026 Java roadmap highlights preview releases for value types, code reflection, AOT compilation, and structured concurrency, detailing progress on Project Loom, Valhalla, Panama, Amber, and Babylon, while noting timelines, goals, and the uncertainty of exact release dates.
AOT CompilationJDKJava
0 likes · 6 min read

This article explains how Java's new virtual threads (Project Loom) can transform Spring Boot applications, delivering up to three‑fold QPS improvements and up to 67% lower memory usage, by replacing heavyweight platform threads with lightweight coroutine‑style execution, and provides detailed comparisons, benchmarks, code samples, and migration guidance.
JavaProject Loomperformance
0 likes · 51 min read

This article explains the C10K problem and provides practical, non‑blocking and reactive strategies, thread‑count minimization, Netty configuration, memory management, and emerging technologies like GraalVM Native‑Image and Project Loom to keep Java servers stable under massive concurrent connections.
C10KGraalVMJava performance
0 likes · 10 min read

This article demonstrates how to integrate Project Loom virtual threads into a Spring Boot application, provides the necessary Maven configuration and Java code, runs load tests with JMeter to compare response times against traditional threads, and shows the significant throughput improvements achieved on the same hardware.
JavaProject Loomperformance testing
0 likes · 9 min read

Modern Java introduces lambda expressions and the Stream API for functional programming, while upcoming projects—Loom’s virtual threads, Panama’s foreign function and memory API, and Valhalla’s value classes and generic specialization—address concurrency, native interop, and performance, dramatically enhancing developer productivity and language capabilities.
JavaProject LoomProject Panama
0 likes · 18 min read


21CTONov 22, 2024 · Fundamentals
Chief designer Michail Zarečenskij explains Kotlin’s evolution from a Java alternative to a multiplatform language, its ongoing reliance on JVM interoperability, hopes for Project Valhalla, the impact of Project Loom on coroutines, and upcoming features slated for the next Kotlin release.
CoroutinesJVMKotlin
0 likes · 7 min read

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.
JMeterProject Loomperformance testing
0 likes · 8 min read

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.
JDK21JavaProject Amber
0 likes · 13 min read

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.
Java ConcurrencyProject Loomperformance testing
0 likes · 8 min read

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.
Java ConcurrencyProject Loomperformance testing
0 likes · 7 min read

Spring Framework 6.0.0 has been officially released, introducing a Java 17+ baseline, migration to Jakarta EE 9+ namespaces, support for the latest Jakarta EE 10 APIs, AOT compilation for GraalVM native images, virtual threads via Project Loom, and enhanced HTTP client observability.
AOTGraalVMJakarta EE
0 likes · 5 min read
