book

Modern Concurrency in Java

by A N M Bazlur Rahman

September 2025

Intermediate to advanced

336 pages

8h 23m

English

O'Reilly Media, Inc.

Book available

Read now

Unlock full access

Why I Wrote This BookWho This Book Is ForWhat This Book OffersHow This Book Is OrganizedHow to Read This BookA Hands-On ApproachConventions Used in This BookO’Reilly Online LearningHow to Contact UsAcknowledgments
A Brief History of Threads in JavaJava Is Made of ThreadsThreads: The Backbone of the Java PlatformThe Genesis of Java 1.0 ThreadsStarting ThreadsUnderstanding the Hidden Costs of ThreadsHow Many Threads Can You Create?Resource Efficiency in High-Scale ApplicationsThe Parallel Execution StrategyIntroducing the Executor FrameworkRemaining ChallengesBeyond Basic Thread PoolsCache Affinity and Task DistributionWork-Stealing AlgorithmBringing Composability into Play with CompletableFutureA Different Paradigm for Asynchronous ProgrammingDrawbacks of Using Reactive FrameworksRevolutionizing Concurrency in JavaThe Promise of Virtual ThreadsSeamless Integration with Existing CodebasesVirtual Threads and Platform ThreadsIntelligent Handling of Blocking OperationsBenefits of Embracing Virtual ThreadsIn Closing
What Is a Virtual Thread?The Two Kinds of Threads in JavaKey Differences from Platform ThreadsSetting Up Your Environment for Virtual ThreadsCreating Virtual Threads in JavaAdapting to Virtual ThreadsDemonstrating Virtual Thread Creation in JavaThroughput and ScalabilityThe Fundamental Principle Behind Virtual Threads’ ScalabilityThe Practical ImplicationsHow Virtual Threads Work Under the HoodStack Frames and Memory ManagementCarrier Threads and OS InvolvementHandling Blocking OperationsTransparency and InvisibilitySimplifying Asynchronous OperationsThe Promise of Structured ConcurrencyManaging Resource Constraints with Rate LimitingUnderstanding Semaphores in JavaWhy Use a Semaphore?Limitations of Virtual ThreadsPinningAddressing the Pinning Problem with ReentrantLockNative Method Invocation and PinningThe Conundrum of ThreadLocal Variables in Virtual ThreadsChallenges with Virtual ThreadsMonitoringMonitoring ThreadLocalsMonitoring PinningViewing Virtual Threads in jcmd Thread DumpsGenerating Thread Dumps with HotSpotDiagnosticsMXBeanPractical Tips for Migrating to Virtual ThreadsReaffirming the Benefits of Virtual ThreadsIt’s About ScalabilityIn Closing
Thread PoolWhy Do We Need a Thread Pool?Building a Simple Thread Pool in JavaThe Executor FrameworkCallable and Future: Handling Task ResultsThe ForkJoinPoolWhy ForkJoinPool for Virtual Threads?ContinuationBuilding Our Own Virtual Threads from ScratchVirtual Threads and I/O PollingIn Closing
The Challenge of Unstructured ConcurrencyThe Promise of Structured ConcurrencyUnderstanding the APIStructuredTaskScopeScopes and Subtasks: Relationship and LifecycleJoining Policies with JoinerCommon Joining PoliciesException Handling in StructuredTaskScopeConfigurationCustom JoinersMemory Consistency EffectsNested ScopesObservabilityIn Closing
The Burden of Passing ContextParameter PollutionInterface BrittlenessCoupling and TestabilityIntroducing ThreadLocalLimitations of ThreadLocal VariablesToward Lightweight SharingCore Components of ScopedValueRunning ScopedValueScopedValue and Structured ConcurrencyPerformance ConsiderationsUsability and API DesignMigrating to Scoped ValuesIn Closing
Understanding Reactive Programming in JavaBlocking Versus Non-blocking I/OEvent-Driven ArchitectureAsynchronous APIsReactive Programming in JavaUnderstanding Reactive StreamsBackpressureBenefits and Downsides of Reactive ProgrammingIn Closing
Spring BootManual ConfigurationQuarkusJakarta EEIn Closing

Overview

Welcome to the future of Java. With this book, you'll explore the transformative world of Java 21's key feature: virtual threads. Remember struggling with the cost of thread creation, encountering limitations on scalability, and facing difficulties in achieving high throughput? Those days are over. This practical guide takes you from Java 1.0 to the cutting-edge advancements of Project Loom.

You'll learn more than just theory. Author A N M Bazlur Rahman equips you with a toolkit for taking real-world action. Take a deep dive into the intricacies of virtual threads and complex topics such as ForkJoinPool, continuation, rate limiting, debugging, and monitoring. You'll not only learn how they work, but you'll also pick up expert tips and tricks to help you master these concepts. And you'll learn about structured concurrency and scoped values—critical skills for building Java applications that are scalable and efficient.

Get an in-depth understanding of virtual threads
Understand the implementation of virtual thread internals
Gain performance improvement in blocking operations
Learn why structured concurrency is beneficial
Know where to use scoped value
Understand the relevance of reactive Java with the advent of virtual threads

A N M Bazlur Rahman is a software engineer with over a decade of experience in Java and related technologies. A speaker at various international conferences and Java user groups, his talks often focus on specialized topics such as concurrency and virtual threads.