Multithreading,Parallel & Asynchronous Coding in Modern Java

Multithreading,Parallel & Asynchronous Coding in Modern Java, available at $79.99, has an average rating of 4.5, with 69 lectures, based on 1651 reviews, and has 13298 subscribers.

You will learn about Learn to write code that provides faster results using the modern apis in Java Learn to write Asynchronous/Parallel Programming code using Functional Style APIs Learn to write parallel programming code using ParallelStreams Learn to write Asynchronous code using Completablefuture Learn to write code that uses all the cores in your machine Techniques and patterns that uses the modern concurrency apis to improve the overall performance of the code Concurrency vs Parallelism This course is ideal for individuals who are Java Developers curious to write parallel programming code or Java Developers curious to write Asynchronous programming code or Java Developers interested in improving the knowledge about the Modern Concurrency APIs or Java Developers interested in learning the ParallelStreams API or Java Developers interested in learning the CompletableFuture API It is particularly useful for Java Developers curious to write parallel programming code or Java Developers curious to write Asynchronous programming code or Java Developers interested in improving the knowledge about the Modern Concurrency APIs or Java Developers interested in learning the ParallelStreams API or Java Developers interested in learning the CompletableFuture API.

Enroll now: Multithreading,Parallel & Asynchronous Coding in Modern Java

Summary

Title: Multithreading,Parallel & Asynchronous Coding in Modern Java

Price: $79.99

Average Rating: 4.5

Number of Lectures: 69

Number of Published Lectures: 65

Number of Curriculum Items: 75

Number of Published Curriculum Objects: 71

Original Price: $89.99

Quality Status: approved

Status: Live

What You Will Learn

Learn to write code that provides faster results using the modern apis in Java
Learn to write Asynchronous/Parallel Programming code using Functional Style APIs
Learn to write parallel programming code using ParallelStreams
Learn to write Asynchronous code using Completablefuture
Learn to write code that uses all the cores in your machine
Techniques and patterns that uses the modern concurrency apis to improve the overall performance of the code
Concurrency vs Parallelism

Who Should Attend

Java Developers curious to write parallel programming code
Java Developers curious to write Asynchronous programming code
Java Developers interested in improving the knowledge about the Modern Concurrency APIs
Java Developers interested in learning the ParallelStreams API
Java Developers interested in learning the CompletableFuture API

Target Audiences

Java Developers curious to write parallel programming code
Java Developers curious to write Asynchronous programming code
Java Developers interested in improving the knowledge about the Modern Concurrency APIs
Java Developers interested in learning the ParallelStreams API
Java Developers interested in learning the CompletableFuture API

This course is structured to give you the theoretical and coding experience writing parallel and asynchronous code using ParallelStreams and CompletableFuture. You will become very Fluent in writing Asynchronous/Parallel Code in Java once you complete this course.

If you are looking forward to writing High Performant Java code then this is the right course for you. This course covers the latest features that are available in Modern Java that helps you write fast performing code.

This course explicitly covers the following APIs in Modern Java:

ParallelStreams
CompletableFuture

Getting Started with Parallel and Asynchronous programming

In this section, I will explain about the need to learn about the Parallel and Asynchronous programming concepts in todays software development
Briefly talks about the Evolution of Concurrency APIs in Java
Explain about the difference between the Concurrency and Parallelism

Course Project SetUp

In this section, we will set up the base project for the whole course.

Threads, Future, ForkJoin FrameWork, and its Limitations

In this section, I will explain about Threads, Future API, ForkJoin FrameWork and its limitations
I will show a demonstration of all these concepts using code examples.
The limitations that are covered in the course sets the stage for ParallelStreams and CompletableFuture API

Getting started with Parallel Streams

In this section, I will introduce you all to parallel streams and implement a simple example using Parallel Streams
Introduction to Streams API and ParallelStreams
Implement a simple example using ParallelStreams
Write unit tests to test the ParallelStreams using JUnit5

Build Retail Checkout Application using Parallel Streams

In this section, we will build a simple Backend Retail Checkout application using Parallel Streams

Parallel Streams – Under the hood

In this section, I will cover the internals of parallel streams.
I will explain about how ParallelStreams work under the hood
Compare the performance of different collections when it’s used against the ParallelStreams
Usage of Collect vs Reduce terminal operators in Streams API and Parallel Streams
Operators that can cause poor performance when it’s used against ParallelStreams

Parallel Streams – Threading Model & Common ForkJoin Pool

In this section, I will explain about the execution engine behind the parallel Streams
Covers the Threading model that’s utilized behind the scenes by ParallelStreams
Configuring the ThreadPool for Faster Performance

Parallel Streams – Summary

This section summarizes everything that’s discussed above that’s related to ParallelStreams
Covers the scenarios on “when to use/when not to use” ParallelStreams

CompletableFuture

In this section, I will introduce you all to the CompletableFuture API

Exploring CompletableFuture Functions

In this section, I will code and explore the functions that are part of the CompletableFuture API
Explore some of the key functions that are part of the CompletableFuture API
Write unit tests to test the CompletableFuture using JUnit5

Build a ProductService application using CompletableFuture

In this section, we will implement the ProductService example using CompletableFuture
This section will give you all an idea about how to use CompletableFuture in a real-world scenario

Combining Streams and CompletableFuture

In this section, I will show you the techniques to combine Streams with CompletableFuture.
I will explore this by adding an enhancement to the ProductService which is the InventoryService
Explore the different options available to integrate Streams API with CompletableFuture

Exception Handling/Recovery in CompletableFuture

In this section, I will introduce you to to the techniques/options that are to handle/recover exceptions using CompletableFuture
I will explain and cover different exception handling and recovery techniques that are available in CompletableFuture
- handle()
- exceptionally()
- whenComplete
I will compare and explain the difference of behaviors between them and provide recommendation on using different handlers for different use cases.

Implement Exception Handling/Recovery in ProductService

In this lecture, I will show you techniques to implement the exception handling techniques in our ProductService
Implement the exception handling and recovery technique in ProductInfoService, ReviewService and InventoryService

CompletableFuture & ThreadPool

In this section, I will cover the ThreadPool and the different options that are available to use with CompletableFuture

I will cover the default CommonForkJoin ThreadPool thats used to execute the CompletableFuture
I will cover the techniques to use a Custom ThreadPool that can be used to execute the CompletableFuture

Threads and Async Overloaded Methods in CompletableFuture

I will cover the threads that are used to execute CompletableFuture
I will show the technique to use Async()methods that’s part of the CompletableFuture API to change the execution of threads in the CompletableFuture Pipeline

Build RestFul API Client using Spring WebClient and CompletableFuture

In this section, I will build a restful api client using Spring WebClient and Integrate with CompletableFuture to improve the performance of the api calls.
I will code and demonstrate how to use Spring WebClient to build a rest client
I will code and demonstrate the technique to integrate RestAPI calls with CompletableFutureto improve the overall performance of the code.

Handle Multiple CompletableFutures – anyOf(), allOf()

In this section, I will code and explain about the techniques to handle multiple CompletableFutures.
I will code and explore the allOf() function thats part of the CompletableFuture API
I will code and explore the anyOf() function thats part of the CompletableFuture API

By the end of this course, you will have a complete understanding of ParallelStreams and CompletableFuture and how to use them in your projects.

Course Curriculum

Chapter 1: Getting Started With the Course

Lecture 1: Course Introduction & Objectives

Lecture 2: Prerequisites

Chapter 2: Course Slides

Lecture 1: Course Slides

Lecture 2: Source Code

Chapter 3: Getting Started with Parallel and Asynchronous programming

Lecture 1: Why Parallel Programming and Asynchronous Programming?

Lecture 2: Evolution of Concurrency/Parallelism APIs in Java

Lecture 3: Concurrency vs Parallelism

Chapter 4: Course Project SetUp

Lecture 1: Course Project SetUp

Chapter 5: Threads, Future, ForkJoin and its Limitations

Lecture 1: Section Overview

Lecture 2: Overview of the Service & Code Walkthrough

Lecture 3: Threads and its Limitations – Hands On

Lecture 4: Introduction to ThreadPool/ExecutorService & Future

Lecture 5: ExecutorService/Future and its limitations – Hands On

Lecture 6: Fork-Join Framework

Lecture 7: Fork Join Framework – Hands On

Chapter 6: Getting started with Parallel Streams

Lecture 1: Introduction to Streams API & Parallel Streams

Lecture 2: Parallel Streams – Hands On

Lecture 3: Unit Testing Parallel Streams – JUnit5

Lecture 4: Sequential() and Parallel() Functions in Streams API

Chapter 7: Build Retail Checkout Application using Parallel Streams

Lecture 1: Overview of the Application

Lecture 2: Implement the Checkout Application using parallel Streams

Lecture 3: Unit Test for the Checkout Application – JUnit5

Chapter 8: Parallel Streams – Under the hood

Lecture 1: Parallel Streams – How it works ?

Lecture 2: Comparing Spliterator Performances – ArrayList vs LinkedList – Part 1

Lecture 3: Comparing Spliterator Performances – ArrayList vs LinkedList – Part 2

Lecture 4: Parallel Streams – Final Computation Result Order

Lecture 5: Collect & Reduce Terminal Operation in Parallel Streams

Lecture 6: Collect vs Reduce – Hands On

Lecture 7: Identity in reduce() Operator

Lecture 8: Streams API Operators – Poor Performance

Chapter 9: Parallel Streams – Threading Model & Common ForkJoin Pool

Lecture 1: Internals of Common ForkJoin Pool

Lecture 2: Parallelism & Threads in ForkJoin Pool

Lecture 3: Modifying the Default parallelism in Parallel Streams

Chapter 10: Parallel Streams – Summary

Lecture 1: Parallel Streams – Summary

Chapter 11: CompletableFuture

Lecture 1: Introduction to CompletableFuture

Chapter 12: Exploring CompletableFuture Functions

Lecture 1: Lets write our first CompletableFuture

Lecture 2: Transform Data using "thenApply()"

Lecture 3: Unit Testing CompletableFuture using JUnit5

Lecture 4: Combing independent Async Tasks using "thenCombine"

Lecture 5: Combing 3 Independent Async Tasks using "thenCombine"

Lecture 6: Invoking Async Tasks using "thenCompose"

Chapter 13: Build ProductService Application using CompletableFuture

Lecture 1: Implement ProductService using CompletableFuture – Approach 1

Lecture 2: Implement ProductService using CompletableFuture – Approach 2

Chapter 14: Combining Streams and CompletableFuture

Lecture 1: Adding Inventory Details to a Product

Lecture 2: Integrate InventoryService in ProductService – Approach 1

Lecture 3: Integrate InventoryService in ProductService – Approach 2

Chapter 15: Exception Handling/Recovery in CompletableFuture

Lecture 1: Different Strategies/Options to handle Exceptions in CompletableFuture

Lecture 2: Handle/Recover Exceptions using "handle" function

Lecture 3: Handle/Recover Exceptions using "handle" function – Part2

Lecture 4: Handle/Recover Exceptions using "handle" function – Part3

Lecture 5: Handle/Recover Exceptions using "exceptionally" function

Lecture 6: Handling Exceptions using "whenComplete" function

Chapter 16: Implement Exception Handling/Recovery in ProductService

Lecture 1: Handle/Recover Exceptions in ReviewService

Lecture 2: Handle/Recover Exceptions in ProductInfoService

Chapter 17: CompletableFuture & Threadpool

Lecture 1: CompletableFuture – Default ThreadPool

Lecture 2: CompletableFuture – User Defined ThreadPool using ExecutorService

Chapter 18: Threads and Async Overloaded Methods in CompletableFuture

Lecture 1: Threads in CompletableFuture

Lecture 2: Async() overloaded functions in CompletableFuture

Chapter 19: Build RestFul API Client using Spring WebClient and CompletableFuture

Lecture 1: Introduction to Spring WebClient and Overview of the Movies RestFul API

Lecture 2: Build the RestClient for MoviesService

Lecture 3: Write JUnit for the MoviesService Rest Client

Lecture 4: Combining CompletableFuture and RestClient

Lecture 5: Retrieving Multiple Movies using Spring WebClient and CompletableFuture

Chapter 20: Handle Multiple CompletableFutures – anyOf(), allOf()

Lecture 1: Dealing with Multiple CompletableFutures – allOf()

Lecture 2: Dealing with Multiple CompletableFutures – anyOf()

Instructors

Pragmatic Code School
Technology Enthusiast, Online Instructor

Rating Distribution

1 stars: 12 votes
2 stars: 18 votes
3 stars: 112 votes
4 stars: 590 votes
5 stars: 923 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!

Menu