Mastering Modern Concurrency in Java
Mastering Modern Concurrency in Java
A Deep Dive into Virtual Threads, Structured Concurrency, and Scoped Values
About the Book
Java concurrency has evolved significantly over the years, and with the introduction of virtual threads, Java offers a new paradigm for writing scalable and maintainable concurrent programs. This book aims to be your comprehensive guide to mastering virtual threads and modern concurrency in Java.
What You Will Learn
- Deep dive into the architecture and inner workings of virtual threads.
- Best practices for using virtual threads in various types of Java applications.
- Advanced topics such as debugging and monitoring virtual threads.
- Real-world examples and case studies to apply your knowledge.
- Pitfalls to avoid and how to troubleshoot common issues.
Who This Book Is For
This book is designed for intermediate-to-advanced Java developers who are familiar with the basics of concurrency but want to take their skills to the next level. Software architects and senior developers will also find this book valuable for designing and improving the performance of Java applications.
Structure of The Book
- Introduction to Virtual Threads: Basic concepts and how they differ from traditional threads.
- Concurrency Models in Java: A look at how concurrency has evolved in Java and where virtual threads fit in.
- Practical Use-Cases: Extensive code examples and real-world scenarios where virtual threads shine.
- Advanced Topics: Debugging, monitoring, and pinning, among other advanced topics.
- Practical Advice: Guidelines, best practices, and what to avoid for effective use of virtual threads.
Features
- In-depth explanation and code examples for each topic.
- Hands-on exercises and solutions.
- Real-world case studies.
- Best practices and guidelines.
Pre-requisites
Readers should have a solid understanding of Java and a basic knowledge of threading and concurrency concepts.
By the end of this book, you'll have a thorough understanding of virtual threads and how to use them effectively to write scalable and maintainable Java applications.
About the Author
Table of Contents
- Chapter 0 - Introduction
- A Brief History of Threads in Java
- Java Is Made of Threads
- Threads Are All Layers in Java Platform
- Exceptions
- Debugger and Threads
- Profiler and Threads
- ThreadLocal
- Threads are an integral part of the Java
- The Genesis: Java 1.0 Threads
- Starting Threads
- However, Threads are Expensive: The Hidden Costs
- The Illusion of Infinite Throughput
- OS-Level Limitations
- Context Switching Overhead
- Experiment: How Many Threads Can You Create?
- The Contemporary Challenge: Resource Efficiency in High-Scale Applications
- The Need for Efficient Resource Utilization
- The Limitations of Traditional Threading Models
- The Cost of Blocking Calls
- The Cost of Inactivity
- Evolving Solutions in Java's History
- The Parallel Execution Strategy
- The Pitfalls of Ad Hoc Thread Creation
- Advancing to the Executor Framework: A Step Forward, Yet Not the Endgame
- Introduction of Executors, Future, and Callable
- Advantages and Remaining Challenges
- Embracing Fork/Join Pool: A Leap Towards Efficient Multithreading
- Introduction to Fork/Join Pool
- Cache Affinity and Task Distribution
- Work-Stealing Algorithm
- Bringing Composability into Play with CompletableFuture
- CompletableFuture
- Composable and Fluent API
- Advantages of Using CompletableFuture
- Disadvantages and Limitations
- Exploring Reactive Java: A Different Paradigm for Asynchronous Programming
- Reactive Frameworks
- Spring WebFlux Example
- Drawbacks of Using Reactive Frameworks
- The Dawn of Project Loom: Redefining Concurrency in Java
- The Promise of Virtual Threads
- Seamless Integration with Existing Code
- Virtual Threads and Platform Threads
- Intelligent Handling of Blocking Calls
- Benefits of Using Virtual Threads
- Structured Concurrency: Organizing Asynchronous Chaos
- Scoped Values: Context Propagation Made Easy
- How These Features Revolutionize Concurrent Programming in Java
- Simplifying Complexity with Structured Concurrency
- Contextual Awareness through Scoped Values
- Unprecedented Scalability with Virtual Threads
- Synergistic Benefits
- A Brief History of Threads in Java
- Chapter 1: Understanding Virtual Threads
- Introduction
- The architecture of Virtual Threads
- Key Differences from Classical Threads
- The Role of Virtual Threads in Modern Java Applications
- The Two Kinds of Threads in Java: Traditional and Virtual
- Setting Up Your Environment for Virtual Threads
- Installing JDK with SDKMAN
- Creating Virtual Threads in Java
- Using the Thread Factory Method
- Using the Builder Method
- Using Executors
- Thread API Changes: Adapting to Virtual Threads
- Familiarity with a Twist
- New and Updated Methods
- Deprecated Methods
- Limitations
- The Power of Scalability: Demonstrating Virtual Thread Creation in Java
- Virtual Threads in Action
- Compared with Traditional Threads
- Throughput and Scalability
- Ideal Use-Cases for Virtual Threads
- Little's Law: The Fundamental Principle Behind Virtual Threads' Scalability
- Understanding Little's Law
- The universality of Little's Law
- Virtual Threads and Little's Law
- The Practical Implications
- How Virtual Threads Work: Under the Hood
- Stack Frames and Memory Management
- Carrier Threads and OS Involvement
- Handling Blocking Operations
- Transparency and Invisibility
- Virtual Threads and Virtual Memory: A Symbiotic Relationship
- Aggregating Task Results with Virtual Threads
- The Promise of Structured Concurrency
- Managing Resource Constraints with Rate Limiting
- Understanding Semaphores in Java
- How Does a Semaphore Work?
- Example Usage of Semaphore:
- Why Use a Semaphore?
- Limitations and Considerations
- Limitations of Virtual Threads: The Pinning Dilemma
- What is Pinning?
- When Does Pinning Occur?
- Why is Pinning a Limitation?
- Mitigating Pinning
- Deeper Dive into Pinning: A Practical Example
- Why This Matters
- Addressing the Pinning Problem with ReentrantLock
- Key Points in the Code:
- Expected Output and Interpretation
- The Conundrum of ThreadLocal Variables in Virtual Threads
- What are ThreadLocal Variables?
- The Classic Use Cases
- The Problem with Overuse in Virtual Threads
- Alternatives and Solutions
- Example: Using ThreadLocal in Virtual Threads
- Monitoring
- Observations from Output:
- Implications:
- Debugging Virtual Threads with Java Flight Recorder
- Java Flight Recorder Events for Virtual Threads
- Enabling JFR Events
- Viewing Virtual Threads in jcmd Thread Dumps
- Generating Thread Dumps
- Analyzing Thread Dumps
- Limitations
- Programmatic Thread Dumps in Java
- Practical Advice for Virtual Threads
- Don't Pool Virtual Threads
- Use Semaphores for Limited Resources
- Avoid Pinning
- Review Usage of Thread-Local Variables
- Case study
- Case Study: Benchmarking Java Virtual Threads vs Platform Threads in a Simple HTTP Server
- Introduction: Setting the Scene
- The Server Design: A Brief Overview
- The Server Code: A Deep Dive
- Switching Between Fixed Thread Pool and Virtual Threads
- Benchmarking: Fixed Thread Pool vs Virtual Threads
- Additional Benchmarking with Apache Bench
- Concluding Remarks
- Introduction
- Chapter 2: The Mechanics
- Introduction
- Introduction to ForkJoin Pool
- What is the ForkJoin Pool?
- The Role in Modern Java
- Key Characteristics
- Significance for Virtual Threads
- How the ForkJoin Pool Works in Scheduling Virtual Threads
- Scheduling Paradigm: M:N Scheduling
- Scheduler Type
- Tunable Parallelism
- Limiting the Number of Carrier Threads
- Limiting the Maximum Number of Carrier Threads
- The Concept of a Carrier Thread
- Independence from Carrier
- Native Code Considerations
- No Time Sharing
- ForkJoinPool in Virtual Threads
- Introduction to ForkJoin Pool
- Continuations in Virtual Threads
- What Are Continuations?
- Mechanics of Continuations
- Interaction with Virtual Threads and ForkJoinPool
- Stack Management in JVM's Continuations and Virtual Threads
- The Need for Stack Management
- Lazy Copy: An Efficient Approach
- What is Lazy Copy?
- How Does Lazy Copy Work?
- Stack Chunks: A Novel Data Structure
- What Are Stack Chunks?
- Mutable and Immutable Phases
- The Role of Metadata and "OopMaps"
- Garbage Collection (GC) and Object References in JVM's
- Continuations and Virtual Threads
- The Importance of GC in Stack Management
- Object References ("Oops")
- What Are "Oops"?
- Metadata and "OopMaps"
- Heap Storage for Stack Frames
- GC and Stack Chunks
- Optimizations and Challenges
- What Are Continuations?
- Introduction
The Leanpub 60 Day 100% Happiness Guarantee
Within 60 days of purchase you can get a 100% refund on any Leanpub purchase, in two clicks.
Now, this is technically risky for us, since you'll have the book or course files either way. But we're so confident in our products and services, and in our authors and readers, that we're happy to offer a full money back guarantee for everything we sell.
You can only find out how good something is by trying it, and because of our 100% money back guarantee there's literally no risk to do so!
So, there's no reason not to click the Add to Cart button, is there?
See full terms...
Earn $8 on a $10 Purchase, and $16 on a $20 Purchase
We pay 80% royalties on purchases of $7.99 or more, and 80% royalties minus a 50 cent flat fee on purchases between $0.99 and $7.98. You earn $8 on a $10 sale, and $16 on a $20 sale. So, if we sell 5000 non-refunded copies of your book for $20, you'll earn $80,000.
(Yes, some authors have already earned much more than that on Leanpub.)
In fact, authors have earnedover $14 millionwriting, publishing and selling on Leanpub.
Learn more about writing on Leanpub
Free Updates. DRM Free.
If you buy a Leanpub book, you get free updates for as long as the author updates the book! Many authors use Leanpub to publish their books in-progress, while they are writing them. All readers get free updates, regardless of when they bought the book or how much they paid (including free).
Most Leanpub books are available in PDF (for computers) and EPUB (for phones, tablets and Kindle). The formats that a book includes are shown at the top right corner of this page.
Finally, Leanpub books don't have any DRM copy-protection nonsense, so you can easily read them on any supported device.
Learn more about Leanpub's ebook formats and where to read them
