Modern Java: Stream Gatherers & Scalable Concurrency

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.