Practical utilities
This article explains how to improve RAG retrieval quality by combining vector and keyword search via RRF fusion, adding cross-encoder reranking, rewriting user queries for better retrieval, and using HyDE to generate hypothetical answers for embedding-based search, with a practical Java implementation example.
The article explains why platform threads are costly, how JDK 21 virtual threads eliminate that cost, and provides practical guidance on creating, using, and debugging virtual threads, including pinning pitfalls, rules against pooling, structured concurrency, ScopedValue, and a detailed model‑selection comparison.
The article explains how to replace blocking Future with CompletableFuture for efficient asynchronous orchestration, covering task chaining, parallel execution, exception handling, and Fork/Join, and demonstrates a complete seckill order pipeline that reduces latency by parallelizing independent steps.
This article explains how Java's synchronization utilities—CountDownLatch, CyclicBarrier, Semaphore, Phaser, and Exchanger—solve coordination problems such as one‑time startup waits, repeated barrier synchronization, resource‑quota limiting, dynamic multi‑stage collaboration, and two‑thread data exchange, with concrete code examples and a full seckill‑system case study.
This article explains why HashMap isn’t thread‑safe, how Hashtable’s single lock hurts performance, and walks through the evolution from JDK 1.7 segment locks to JDK 1.8’s CAS‑plus‑synchronized bucket locking, including lock‑free size counting and a comparison with CopyOnWriteArrayList for read‑heavy scenarios.
This article explains why creating raw threads in production is costly, breaks down the seven ThreadPoolExecutor parameters, shows the exact execution flow of a submitted task, compares queue choices and Executors factories, and provides practical tuning, rejection‑policy and graceful‑shutdown guidance.
This article explains how deadlocks arise from four necessary conditions, shows how to detect them with jstack, outlines practical ways to prevent deadlock, distinguishes livelock and starvation, and presents three prioritized approaches—immutability, thread confinement, and synchronization—to achieve thread safety in Java.
This article dissects Java’s AbstractQueuedSynchronizer (AQS), explaining its three core components—volatile state, CAS, and a FIFO wait queue—how exclusive and shared modes operate, the step‑by‑step lock acquisition flow, ReentrantLock implementation details, fairness trade‑offs, and the underlying template‑method design pattern.
This article demystifies Java's Compare‑And‑Swap (CAS) instruction, shows how atomic classes like AtomicInteger achieve lock‑free increments, discusses CAS's three main drawbacks, surveys the entire java.util.concurrent.atomic family, and explains how LongAdder improves high‑contention counting.
The article explains why Java concurrency is difficult by showing that two threads each incrementing an int ten thousand times may not produce twenty thousand, then explores the motivations for multithreading, the differences between concurrency and parallelism, and the three core challenges of visibility, atomicity, and ordering.
