Java Virtual Threads Concurrency Masterclass [Hands-On]

Java Virtual Threads & Concurrency Masterclass [Hands-On], available at $89.99, has an average rating of 4.67, with 110 lectures, 2 quizzes, based on 127 reviews, and has 1625 subscribers.

You will learn about Java Virtual Threads Fundamentals Scalability Challenges with Traditional Threads Effective Use of Executor Service with Virtual Threads Asynchronous Task Processing with Completable Future Practical Application Development with Spring Boot Web Scalability Testing using JMeter This course is ideal for individuals who are Any Java Developer who likes to learn more about Virtual Threads It is particularly useful for Any Java Developer who likes to learn more about Virtual Threads.

Enroll now: Java Virtual Threads & Concurrency Masterclass [Hands-On]

Summary

Title: Java Virtual Threads & Concurrency Masterclass [Hands-On]

Price: $89.99

Average Rating: 4.67

Number of Lectures: 110

Number of Quizzes: 2

Number of Published Lectures: 110

Number of Published Quizzes: 2

Number of Curriculum Items: 112

Number of Published Curriculum Objects: 112

Original Price: $19.99

Quality Status: approved

Status: Live

What You Will Learn

Java Virtual Threads Fundamentals

Scalability Challenges with Traditional Threads

Effective Use of Executor Service with Virtual Threads

Asynchronous Task Processing with Completable Future

Practical Application Development with Spring Boot Web

Scalability Testing using JMeter

Who Should Attend

Any Java Developer who likes to learn more about Virtual Threads

Target Audiences

Any Java Developer who likes to learn more about Virtual Threads

Dive deep into the intricacies of concurrency & Learn how to make your Java applications run smoother and faster using simple and effective concurrency techniques. From the basics to hands-on projects, this course equips you with the skills to revolutionize your approach to programming.

Course Highlights:

1. Understanding Concurrency: Learn about the challenges of traditional threads and discover how Java Virtual Threads provide a simpler and more efficient solution for making your programs scale seamlessly.

2. Executor Service Mastery: Dive into using Executor Service with Virtual Threads. Overcome challenges, control concurrency, and process tasks more efficiently by breaking them down into parallel subtasks.

3. Completable Future Exploration: Explore Completable Future for asynchronous task processing with Virtual Threads. Learn practical methods, handle timeouts, and manage errors in a declarative style.

4. Preview of Structured Concurrency: Get a sneak peek into Java’s new preview APIs, giving you insights into the future of concurrent programming. Stay ahead of the curve with a simplified understanding of Java’s concurrency development.

5. Practical Application Development: Apply what you’ve learned in a hands-on project using Spring Boot Web and Virtual Threads. See firsthand how these concepts integrate seamlessly into real-world application development.

6. Scalability Testing with JMeter: Test your application’s scalability using JMeter. Compare throughput and response time to ensure optimal efficiency under different conditions.

7. Migration Made Easy: Conclude the course with a practical migration guide to transition your existing applications to Java Virtual Threads effortlessly. Get ready for a future where your programs effortlessly combine concurrency and scalability.

Unlock the full potential of Java Virtual Threads and elevate your programming skills. Enroll now to reshape the way you approach scalability and performance in Java applications!

Course Curriculum

Chapter 1: Introduction

Lecture 1: Introduction

Chapter 2: Deep Dive into Virtual Threads

Lecture 1: Introduction

Lecture 2: *** Resources ***

Lecture 3: Project Setup

Lecture 4: Platform Thread Creation Limit – Demo

Lecture 5: Thread Builder – Factory Method

Lecture 6: Virtual Thread Scaling – Demo

Lecture 7: How Virtual Thread Works

Lecture 8: Carrier Threads Demo

Lecture 9: Virtual Thread & Stack

Lecture 10: OPTIONAL – Getting Stack Trace

Lecture 11: CPU Intensive Task – Part 1

Lecture 12: CPU Intensive Task – Part 2

Lecture 13: CPU Intensive Task – Part 3

Lecture 14: Virtual Thread – Scheduler Config

Lecture 15: Preemptive vs Cooperative Scheduling

Lecture 16: Cooperative Scheduling Demo

Lecture 17: How Virtual Thread Can Help?

Lecture 18: Synchronization

Lecture 19: OPTIONAL – Synchronization For Compute Tasks

Lecture 20: Virtual Thread – Synchronization For IO Tasks

Lecture 21: Pinning Threads

Lecture 22: Tracing Pinned Threads

Lecture 23: Fixing Pinned Threads Using Reentrant Lock

Lecture 24: Virtual Thread Factory

Lecture 25: OPTIONAL – Thread Methods

Lecture 26: Summary

Chapter 3: Executor Service

Lecture 1: Introduction

Lecture 2: Executor Service Types

Lecture 3: Auto Closeable

Lecture 4: Executor Service Types – Demo

Lecture 5: ** Resource ** – External Service

Lecture 6: External Service

Lecture 7: External Service Client

Lecture 8: Access Response Using Future

Lecture 9: OPTIONAL – Concurrency vs Parallelism

Lecture 10: Future Useful Methods

Lecture 11: Aggregator Service

Lecture 12: Do We Create Extra Thread?

Lecture 13: Clarification On Virtual Thread Executor Behavior

Lecture 14: Executor With Virtual Thread Factory

Lecture 15: Executor Service & Virtual Thread Challenges

Lecture 16: Concurrency Limit

Lecture 17: Semaphore

Lecture 18: Virtual Thread Concurrency Limiter

Lecture 19: What about Order?

Lecture 20: Virtual Thread Concurrency Limiter With Order

Lecture 21: Scheduled Executor With Virtual Thread

Lecture 22: Summary

Chapter 4: Completable Future

Lecture 1: Introduction

Lecture 2: How CompletableFuture Works

Lecture 3: Simple CompletableFuture Demo

Lecture 4: Run Async

Lecture 5: Supply Async

Lecture 6: Getting Product Info

Lecture 7: Aggregator – Error Handling With CompletableFuture

Lecture 8: Timeout

Lecture 9: CompletableFuture – All Of

Lecture 10: CompletableFuture – Any Of

Lecture 11: CompletableFuture – Then Combine

Lecture 12: Summary

Chapter 5: ** PREVIEW ** – Scoped Values & Structured Concurrency

Lecture 1: Introduction

Lecture 2: ThreadLocal – Part 1

Lecture 3: ThreadLocal – Part 2

Lecture 4: Scoped Values – Part 1

Lecture 5: Scoped Values – Part 2

Lecture 6: Structured Concurrency

Lecture 7: StructuredTaskScope – Demo

Lecture 8: StructuredTaskScope – ShutDown On Failure

Lecture 9: StructuredTaskScope – ShutDown On Success

Lecture 10: Inheriting Scoped Values

Lecture 11: Summary

Chapter 6: Application Development With Spring & Virtual Threads

Lecture 1: Introduction

Lecture 2: External Services

Lecture 3: Project Setup

Lecture 4: DTO

Lecture 5: ** Resource ** – RestClient

Lecture 6: RestClient – Crash Course

Lecture 7: Service Client

Lecture 8: Trip Plan Service

Lecture 9: Trip Reservation Service

Lecture 10: Trip Controller

Lecture 11: ** Resource ** – Application Properties

Lecture 12: Application Properties

Lecture 13: Service Client Beans

Lecture 14: Executor Service Bean

Lecture 15: Application Demo

Chapter 7: Performance Testing With JMeter

Lecture 1: Introduction

Lecture 2: Throughput vs Response Time

Lecture 3: Setting Up JMeter

Lecture 4: Creating Test Script

Instructors

Vinoth Selvaraj
Principal Engineer

Rating Distribution

1 stars: 0 votes

2 stars: 0 votes

3 stars: 4 votes

4 stars: 38 votes

5 stars: 85 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!