Modern Java: Stream Gatherers & Scalable Concurrency
Published 6/2025
MP4 | Video: h264, 1920x1080 | Audio: AAC, 44.1 KHz
Language: English | Size: 1.98 GB | Duration: 6h 13m
Published 6/2025
MP4 | Video: h264, 1920x1080 | Audio: AAC, 44.1 KHz
Language: English | Size: 1.98 GB | Duration: 6h 13m
Modern Java Stream Gatherers, Virtual Threads, Advanced Concurrency and High-Throughput Scalable I/O Processing
What you'll learn
Build advanced data pipelines using the new Stream Gatherers API in Java
Write stateless and stateful gatherers to control stream flow with custom logic
Integrate Virtual Threads for highly scalable I/O-bound processing
Design non-blocking concurrent gatherers that emit results as they complete
Control concurrency levels to avoid overload using concurrency-limiting gatherers
Handle errors gracefully without disrupting the stream using delay error patterns
Implement nested concurrency in a structured and maintainable way
Improve performance and memory usage with stream-first design and no intermediate collections
Requirements
Familiarity with Java Virtual Threads is recommended. If you are new to Virtual Threads, consider checking out my companion course on the topic for a solid foundation.
Description
Prerequisite: Familiarity with Java Virtual Threads is recommended. If you are new to Virtual Threads, consider checking out my companion course on the topic for a solid foundation.This in-depth course is designed for experienced Java developers looking to master the cutting-edge Stream Gatherers API and unlock the full potential of Virtual Threads for building high-performance, scalable applications.Java has evolved, and so have its concurrency tools. With the introduction of Stream Gatherers and Virtual Threads, you can now write efficient, readable, and scalable I/O pipelines using familiar Stream constructs. This course is practical, modern, and tailored to help you build real-world, concurrent Java applications without the traditional complexity of thread management.What You Will LearnUnderstand how Stream Gatherers enhance the Java Stream APIMaster Stateless Gatherers using integrators for simple yet powerful stream transformationsBuild Stateful Gatherers using initializers for scenarios that require shared or evolving contextImplement Finisher logic for end-of-stream aggregation, cleanup, or final state transformationExplore Combiners and their role in parallel stream executionDeep-dive into built-in gatherers and learn when and how to use them effectivelyWrite your own custom gatherers to unlock advanced stream patternsUse Virtual Threads to handle high-volume I/O-bound tasks with minimal overheadDesign Concurrent Gatherers that:Execute and emit resultsSupport Concurrency Limits to avoid resource exhaustionHandle errors without blocking other operations (e.g. Delay Error pattern)Allow Nested Concurrent Processing for multi-stage, multi-level pipelinesBuild a Massive I/O Stream Pipeline project using Stream Gatherers + Virtual ThreadsIngest 150K+ API calls efficiently with lightweight concurrencyAvoid intermediate collection for better throughput and memory efficiencySave data with batched writes and stream-friendly persistenceWhy Take This Course?Many developers avoid writing high-concurrency code because of complexity and fear of resource management. This course changes that by using Stream Gatherers and Virtual Threads to simplify the process.You will learn how to think in terms of composable data pipelines rather than low-level threads or futures. The examples and patterns you build will help you tackle real I/O-heavy use cases with confidence and performance.
Overview
Section 1: Introduction
Lecture 1 Need For Stream Gatherers
Section 2: Stateless Gatherers
Lecture 2 Stream Terminologies
Lecture 3 Gatherer Components
Lecture 4 *** Humble Request & Resource ***
Lecture 5 Project Setup
Lecture 6 How Integrator Works With Upstream
Lecture 7 How Integrator Works With Downstream
Lecture 8 Quick Recap
Lecture 9 Implementing Filter
Lecture 10 Greedy Integrator
Lecture 11 Sequential Gatherer
Lecture 12 Implementing FlatMap
Lecture 13 [ASSIGNMENT] - Take Until Operator
Lecture 14 [ASSIGNMENT SOLUTION] - Take Until Operator
Lecture 15 Summary
Section 3: Stateful Gatherers
Lecture 16 Initializer
Lecture 17 How Initializer Works
Lecture 18 Distinct Gatherer
Lecture 19 [ASSIGNMENT] - Distinct Recent Gatherer
Lecture 20 Moving Average Gatherer
Lecture 21 Summary
Section 4: Finisher
Lecture 22 How Finisher Works - Part 1
Lecture 23 How Finisher Works - Part 2
Lecture 24 Batch Until Gatherer
Lecture 25 Hierarchical Data Structure - Expand Gatherer - Part 1
Lecture 26 Hierarchical Data Structure - Expand Gatherer - Part 2
Lecture 27 *** Resource ***
Lecture 28 Hierarchical Data Structure - Expand Gatherer - Demo
Lecture 29 Chaining Gatherers
Lecture 30 Downstream isRejecting - Issue & Workaround
Section 5: Stateful Gatherers With Parallel Stream
Lecture 31 Need For Combiner
Lecture 32 How Combiner Works
Lecture 33 Why We Have More SubTasks!
Lecture 34 Parallel Max Gatherer
Lecture 35 TopN Gatherer - Part 1
Lecture 36 TopN Gatherer - Part 2
Lecture 37 Do You Need Parallel Stream?
Section 6: Built-In Gatherers
Lecture 38 Window Fixed vs Window Sliding
Lecture 39 Fold
Lecture 40 Scan
Lecture 41 Map Concurrent
Lecture 42 Parallel vs Map Concurrent - How They Work
Lecture 43 Map Concurrent - Ordering & Potential Issues
Lecture 44 Summary
Section 7: Concurrency Patterns With Virtual Threads & Stream Gatherers
Lecture 45 *** External Services ***
Lecture 46 External Services
Lecture 47 External Service Client
Lecture 48 Map Concurrent
Lecture 49 Execute Concurrent Gatherer Implementation - Part 1
Lecture 50 Execute Concurrent Gatherer Implementation - Part 2
Lecture 51 Execute Concurrent Gatherer Implementation - Part 3
Lecture 52 Execute Concurrent Gatherer - Demo
Lecture 53 Limiting In-Flight Requests
Lecture 54 Delay Error Gatherer Implementation - Part 1
Lecture 55 Delay Error Gatherer Implementation - Part 2
Lecture 56 Delay Error Gatherer - Demo
Lecture 57 ExecutorService: Error Handling Using Data Oriented Programming
Lecture 58 Nested Concurrency - Problem Statement
Lecture 59 [Nested Concurrency] - Aggregate Concurrent Gatherer - Part 1
Lecture 60 [Nested Concurrency] - Aggregate Concurrent Gatherer - Part 2
Lecture 61 [Nested Concurrency] - Max Concurrency Clarification
Lecture 62 What About More SubTasks?
Lecture 63 SubTask Executor - Implementation
Lecture 64 SubTask Executor - Demo
Lecture 65 Timeout Pattern & Potential Issues
Lecture 66 Limitations Of Blocking Integrator
Section 8: Massive I/O With Virtual Threads & Stream Gatherers
Lecture 67 Requirements Discussion
Lecture 68 Project Goal
Lecture 69 Project Setup
Lecture 70 Geo Data Client
Lecture 71 *** Resource ***
Lecture 72 Application Configuration
Lecture 73 Geo Crawler Service Setup
Lecture 74 Intermediate Results Issue
Lecture 75 Geo Crawler Service Implementation
Lecture 76 Geo Crawler Demo
Lecture 77 Connection Reset Error - Issue Fix
Lecture 78 Summary
Section 9: Whats Next?
Lecture 79 Whats Next?
Experienced Java Developers: Those already comfortable with Java fundamentals, including Streams, Lambdas, and core concurrency concepts.,Modern Java Adopters: Developers keen on leveraging the latest features of Java,Architects & Team Leads: Individuals responsible for designing resilient, performant, and scalable Java architectures.