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