Tagged articles
VirtualThreads
21 articles · Page 1 of 1
Java 26, the latest LTS release, delivers over 40% faster startup, 5‑10% higher G1 GC throughput, reduced memory footprint, deeper container awareness, and improved virtual‑thread handling, making it a compelling upgrade for Kubernetes‑deployed Java applications despite a few migration caveats.
CloudNativeContainerAwarenessG1GC
0 likes · 9 min read

This article walks through five proven Java 21 concurrency tuning techniques—including non‑blocking CompletableFuture pipelines, StampedLock for read‑heavy workloads, bounded queues with CallerRunsPolicy, atomic computeIfAbsent usage in ConcurrentHashMap, and correct virtual‑thread patterns—showing how each can dramatically improve throughput and stability in high‑load systems.
CompletableFutureConcurrencyConcurrentHashMap
0 likes · 9 min read

The latest Spring AI 2.0 and Spring Cloud 2025.1 releases make virtual threads the default concurrency model, showing why Java 21 is essential for AI workloads, how Spring Cloud drops Reactive Kafka, adds MVC‑plus‑virtual‑thread support, and what pitfalls developers must avoid.
BackendConcurrencyJava21
0 likes · 13 min read

Upgrading a company's Java stack from JDK 11 to JDK 21, while staying on Spring Boot 2.7.18, provides long‑term security support, leverages virtual threads, new low‑latency garbage collectors, modern language features like records and pattern‑matching, and avoids costly Jakarta EE namespace migration, with detailed steps for pom changes, MongoDB configuration, code adjustments, and post‑upgrade validation.
JDK21JavaVirtualThreads
0 likes · 16 min read

The article details the data structures behind Netty 4.2's AdaptiveByteBufAllocator, explaining how MagazineGroup, Magazine, and Chunk collaborate to manage memory pools, handle thread-local and shared allocation, and use size-classed chunks with free lists for efficient buffer pooling.
AdaptiveByteBufAllocatorByteBufChunk
0 likes · 6 min read

This article explores the limitations of ThreadLocal—memory leaks, data contamination, inheritance issues, and performance overhead—and introduces Java's ScopedValue as a safer, more efficient alternative, covering its core design, basic and advanced usage, performance benchmarks, migration strategies, and real‑world web application examples.
ConcurrencyJavaScopedValue
0 likes · 28 min read

This article explores the limitations of ThreadLocal, introduces Java's new ScopedValue feature, provides detailed usage examples, performance benchmarks, migration strategies, and compares both approaches to help developers decide when and how to adopt ScopedValue in modern backend applications.
ConcurrencyJavaScopedValue
0 likes · 34 min read

This article explains the differences and relationships between processes, threads, coroutines, and virtual threads, provides detailed Java code examples, compares their characteristics and performance, and offers practical guidance on choosing the right concurrency model for various scenarios.
CoroutinesJavaVirtualThreads
0 likes · 17 min read

ScopedValues provide a more efficient, memory‑safe, and virtual‑thread‑friendly alternative to ThreadLocal for managing per‑thread context in Java, eliminating manual cleanup, reducing memory leaks, and simplifying context propagation across threads, as demonstrated by code examples and performance benchmarks.
ConcurrencyScopedValuesThreadLocal
0 likes · 6 min read

This article walks through why Java 8 is being retired and highlights the most useful language features introduced from Java 8 through Java 24—including lambdas, streams, optional, records, sealed classes, virtual threads, and the new Stream Gatherers—providing code examples and practical guidance for modern Java development.
JavaJava8Records
0 likes · 46 min read

This article explains ThreadLocal's role in Java concurrency, the memory‑leak risk when its remove() method is omitted, introduces the new ScopedValue feature in JDK 20 as a safer alternative, and demonstrates practical Spring and StructuredTaskScope examples with complete code snippets.
JavaScopedValueStructuredConcurrency
0 likes · 23 min read

The article walks through the author's personal upgrade from Java 8 to Java 21, comparing preview features, pattern‑matching instanceof, switch expressions, text blocks, the new HTTP client, var inference, virtual threads, records, immutable collections, try‑with‑resources improvements and other enhancements, while rating each feature’s practicality.
JDK21JavaJava8
0 likes · 16 min read

The article introduces JDK 21’s latest long‑term‑support features—including virtual threads, sequenced collections, preview string templates, record patterns, and switch pattern matching—explaining their concepts, benefits, and providing concrete Java code examples for each.
JDK21JavaRecordPatterns
0 likes · 14 min read

Using JDK 21’s standardized Virtual Threads, this guide explains how to design and implement robust asynchronous batch processing, covering common pitfalls like CPU spikes and OOM, best‑practice concurrency controls, task queue architecture, and practical code illustrations.
AsynchronousProcessingBackendBatchProcessing
0 likes · 6 min read

This article explains the fundamentals of ThreadLocal, its memory‑leak pitfalls, introduces the new ScopedValue feature in JDK 20, demonstrates practical Spring‑based use cases, and shows how StructuredTaskScope enables safe structured concurrency with code examples.
ConcurrencyJavaScopedValue
0 likes · 23 min read

This article reviews Oracle's Java 21 LTS release, outlines its new JEP features, compares it with Java 17, shares upgrade experiences including pom updates and runtime fixes, and evaluates generational ZGC and virtual threads with performance tests and code examples.
JavaJava21RecordPatterns
0 likes · 10 min read

This article explains the ThreadLocal mechanism, its memory‑leak pitfalls, introduces the new ScopedValue feature in JDK 20 as a safer alternative, and demonstrates practical Spring and virtual‑thread examples using StructuredTaskScope for modern Java backend concurrency.
ConcurrencyJavaScopedValue
0 likes · 22 min read

This article reviews the Java 21 LTS release, lists its new JEPs, shares an upgrade experience from Java 17, evaluates the generational ZGC and virtual‑thread improvements, demonstrates record‑pattern syntax, and provides code samples and performance observations.
JEPJavaJava21
0 likes · 10 min read

This article explains Java 21 virtual threads, their lightweight nature, cost advantages over platform threads, practical code examples, performance experiments, and how they enable high‑throughput backend applications with minimal code changes.
ConcurrencyJDK21Java
0 likes · 11 min read

The article announces the official GA release of JDK 21, explains common version labels such as Alpha, Beta, RC and LTS, highlights the standout Virtual Threads feature requiring minimal code changes, and reviews the fifteen new JEPs across core libraries, language specifications, HotSpot and security enhancements.
JDK21JavaJavaFeatures
0 likes · 12 min read

The article provides a hands‑on migration guide for moving an internal gateway service from Java 8 to JDK 11 with the G1 garbage collector, detailing a checklist of tool and dependency updates, showcasing up to 105 % performance gains, outlining new language features, virtual‑thread usage, and best‑practice recommendations for a smooth, cost‑effective upgrade.
G1GCJDK11Java
0 likes · 32 min read
