Java Fundamentals: Asynchronous Programming Using CompletionStage

By Jose Paumard
Asynchronous programming is what the CompletionStage API, from the JDK, brings you. This course covers all the patterns you need to create efficient asynchronous data processing pipelines, including thread control and error recovery.
Play course overview
Course info
Rating
(36)
Level
Intermediate
Updated
Jul 30, 2018
Duration
3h 3m
Table of contents
Course Overview
Course Overview 2m
Introducing Asynchronous vs. Concurrent Tasks
Analyzing the Behavior of the Executor Pattern 1m Comparing Event Driven and Message Driven Systems 1m Introduction to the Course, What Are You Going to Learn? 1m Agenda of this Module 1m Who Are You? What Should You Know to Follow this Course? 2m Defining the Technical Vocabulary of Asynchronous Programming 4m Understanding Blocking Calls and Why You Should Avoid Them 2m Agenda of the Course 2m Analyzing the Patterns an Asynchronous API Should Provide 1m Analyzing the Difference Between Concurrent and Asynchronous 3m Understanding the Synchronous Nature of the Observer Pattern 2m Module Wrap Up 1m Using the Executor Pattern to Launch Tasks in Other Threads 4m
Setting up an Asynchronous Operations with CompletionStage
Introduction to the Module and Agenda 1m Comparing the Methods from Future and CompletableFuture 2m Completing or Obtruding a CompletableFuture to Produce a Value 1m Demo: Delaying the Execution of a Supplier Asynchronously 1m Completing or Obtruding a CompletableFuture to Throw an Exception 1m Demo: Creating and Completing a Void CompletableFuture 3m Demo: Executing a Supplier Asynchronously and Getting its Result 2m Using Callable to Create Tasks and Launch Them in Another Thread 1m Demo: Forcing the Completion of a Task Using Complete and Obtrude 2m Module Wrap Up 1m Introducing the Live Demo, Launching a First Task 2m Defining a Task 4m Creating a CompletableFuture from a Runnable or a Supplier 3m Understanding CompletableFuture and CompletionStage 1m Demo: Checking in Which Thread a Task is Running 3m Controlling the Thread Executing a Runnable or a Supplier 4m Getting a Future Object with the Executor Pattern 2m Using Runnable to Create Tasks 1m
Triggering a Task on the Completion of Other Tasks
Launching Runnable, Consumer, and Function After Existing Tasks 3m Sending a Result from a Supplier to a Function 2m Triggering Tasks on the Completion of Two Tasks 2m Demo: Checking in Which Thread an Async Composition is Executed 2m Understanding Single Task Chaining Patterns 3m Demo: Composing a Long Running Task with a CompletableFuture 3m Setting a Pipeline of Tasks as a Map Filter Reduce Pattern 2m Triggering Tasks on the Completion of One of Two Tasks 3m Wrapping up the Patterns for Controlling Threads 1m Demo: Displaying the Result of the First Completed Task 4m Demo: Running the Last Task in a Special Thread 1m Analyzing Use Cases to Choose Which Thread is Executing What Task 4m Introduction to the Module and Agenda 1m Introducing the Live Demo, Chaining the First Tasks 4m Module Wrap Up 3m Demo: Displaying the Result of Two Tasks in a Third One 3m Understanding in Which Thread a Triggered Task is Executed 2m Triggering Tasks on the Completion of Two Completed Tasks 2m Composing CompletableFutures to Prevent Blocking Calls 4m
Dealing with Exception in the CompletionStage Pipeline
Catching an Exception with the Exceptionally Pattern 3m Introducing the Live Demo, Setting up a Chain That Fails 3m Consuming an Exception with the WhenComplete Pattern 2m Module Wrap Up 3m Demo: Setting up the Exceptionally Pattern to Catch an Exception 3m Demo: Logging an Exception Using the WhenComplete Pattern 3m Introduction to the Module and Agenda 1m Introducing How an Exception Affects a Pipeline of Tasks 2m Modifying the Pipeline of Tasks to Catch Exceptions 1m Demo: Providing a Default Value with the Handle Pattern 2m Transforming an Exception with the Handle Pattern 2m Understanding What is Happening When an Exception is Raised 2m Undestanding How a Raised Exception Completes a CompletableFuture 1m
Creating Performant Asynchronous Pipelines with CompletionStage
Demo: Controlling Threads with the Delayed Start Pattern 2m Course Wrap Up 3m Making the HTTP Request Asynchronous Using CompletableFuture 4m Introducing the HTTP Client Example from Java 10 2m Comparing the Executor and the CompletableFuture Patterns 2m Module Wrapup: Three Ideas to Build Performant Async Pipelines 3m Creating the HTTP Client and Request Using the Builder Pattern 2m Understanding the Cost of Moving Tasks to Other Threads 3m Introducing the Live Demo, Setting up the Delayed Start Pattern 5m Writing the CompletableFuture Delayed Start Pattern 3m Analyzing Why the HTTP Request Should Be Made Asynchronously 2m Demo: Delaying the Start of the HttpClient Example 3m Demo: Running the HttpClient Example and Controlling the Threads 4m Using Delayed Start to Create Costly Chains of Tasks 2m Demo: Setting up the HttpClient Example 4m Introduction to the Module and Agenda 1m
Description
Course info
Rating
(36)
Level
Intermediate
Updated
Jul 30, 2018
Duration
3h 3m
Description

As a Java developer, being able to create asynchronous systems allows you to develop very efficient applications, that need both throughput and performance. In this course, Java Fundamentals: Asynchronous Programming Using CompletionStage, you will learn all the patterns brought to you by this API. First, you will learn the concepts of asynchronous programming: tasks, non-blocking calls and multi-threaded systems. Then, you will see how to build data processing pipelines where the completion of a first task automatically triggers the execution of a next task, passing data to it. Finally, you will see how to create performant systems by controlling the execution of each task in the right thread. Mastering all of this will help you in creating performant and error-free asynchronous systems with the only dependency being the JDK itself.

About the author
Jose Paumard
About the author

Passionate about programming computers for over 20 years, Jose made his debut in assembler and C, C for SIMD parallel machines before adopting Java as an object-oriented language. Assistant professor in Paris North University for more than 15 years, Jose also brings his expertise to many projects, in various industrial fields.

More from the author
Working with Files in Java Using the Java NIO API
Intermediate
53m
Apr 3, 2020
Implementing Design Patterns Using Java 8 Lambda
Intermediate
3h 8m
Jul 15, 2019
Java Fundamentals: The Java Reflection API Method Handles
Intermediate
3h 9m
Jan 18, 2019
More courses by Jose Paumard
Section Introduction Transcripts
Section Introduction Transcripts

Course Overview
Hello. My name is Jose. I'm a Java champion and Java 1 rock star. I live in Paris, and I'm very excited to present my new course, Java Fundamentals: Asynchronous Programming Using CompletionStage. This course is about creating asynchronous non-blocking applications and systems in Java. First, you will learn the technical terms, the technical vocabulary you need, then you will see how to set up complex asynchronous data processing pipelines made of tasks that are executed automatically passing data from one another. You will be able to create robust systems, handling errors and exceptions in a proper way to log them or to recover from them. And then you will see how to finally control which thread executes which task for optimal performance, all this with many examples and live demos. Before you move on, be sure to be familiar with all these, the Java language, a little bit of concurrency, and the exception system in Java. Asynchronous programming is not an easy topic, and I will be very happy to show you how it works in the JDK and make the CompletionStage API a tool that will help you become a better Java application developer.

You're the smartest person in the room

PROVE IT

Your team won't just close the skills gap

THEY'LL HURDLE IT