Java Virtual Threads & Concurrency Masterclass [Hands-On]

English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 110 lectures (9h 59m) | 2.07 GB

Multithreading,Structured Concurrency, Executor Service, Scalability, Performance Testing Using JMeter with Spring Boot

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:

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.

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.

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.

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.

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.

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

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!

What you’ll learn

Master Virtual Threads: Learn how to effectively use Virtual Threads to improve the performance and scalability of your Java applications.
Simplify Concurrency: Discover a simpler and more efficient approach to concurrency compared to traditional threads.
Optimize Executor Service: Use Executor Service with Virtual Threads to control concurrency and process tasks efficiently.
Leverage Completable Future: Utilize Completable Future for asynchronous task processing and error handling.
Stay Ahead of the Curve: Get a sneak peek into Java’s new preview APIs for structured concurrency.
Build Scalable Applications: Apply your knowledge to build scalable and performant Java applications.
Test Application Scalability: Use JMeter to test your application’s scalability and performance.
Migrate to Virtual Threads: Learn how to easily migrate your existing applications to Virtual Threads.
Hands-On Project: Build a practical application using Spring Boot Web and Virtual Threads.
Migration Guide: Learn how to easily migrate your existing applications to Virtual Threads.

Table of Contents

Introduction
1 Introduction

Deep Dive into Virtual Threads
2 Introduction
3 Resources
4 Project Setup
5 Platform Thread Creation Limit – Demo
6 Thread Builder – Factory Method
7 Virtual Thread Scaling – Demo
8 How Virtual Thread Works
9 Carrier Threads Demo
10 Virtual Thread & Stack
11 OPTIONAL – Getting Stack Trace
12 CPU Intensive Task – Part 1
13 CPU Intensive Task – Part 2
14 CPU Intensive Task – Part 3
15 Virtual Thread – Scheduler Config
16 Preemptive vs Cooperative Scheduling
17 Cooperative Scheduling Demo
18 How Virtual Thread Can Help
19 Synchronization
20 OPTIONAL – Synchronization For Compute Tasks
21 Virtual Thread – Synchronization For IO Tasks
22 Pinning Threads
23 Tracing Pinned Threads
24 Fixing Pinned Threads Using Reentrant Lock
25 Virtual Thread Factory
26 OPTIONAL – Thread Methods
27 Summary

Executor Service
28 Introduction
29 Executor Service Types
30 Auto Closeable
31 Executor Service Types – Demo
32 Resource – External Service
33 External Service
34 External Service Client
35 Access Response Using Future
36 OPTIONAL – Concurrency vs Parallelism
37 Future Useful Methods
38 Aggregator Service
39 Do We Create Extra Thread
40 Clarification On Virtual Thread Executor Behavior
41 Executor With Virtual Thread Factory
42 Executor Service & Virtual Thread Challenges
43 Concurrency Limit
44 Semaphore
45 Virtual Thread Concurrency Limiter
46 What about Order
47 Virtual Thread Concurrency Limiter With Order
48 Scheduled Executor With Virtual Thread
49 Summary

Completable Future
50 Introduction
51 How CompletableFuture Works
52 Simple CompletableFuture Demo
53 Run Async
54 Supply Async
55 Getting Product Info
56 Aggregator – Error Handling With CompletableFuture
57 Timeout
58 CompletableFuture – All Of
59 CompletableFuture – Any Of
60 CompletableFuture – Then Combine
61 Summary

PREVIEW – Scoped Values & Structured Concurrency
62 Introduction
63 ThreadLocal – Part 1
64 ThreadLocal – Part 2
65 Scoped Values – Part 1
66 Scoped Values – Part 2
67 Structured Concurrency
68 StructuredTaskScope – Demo
69 StructuredTaskScope – ShutDown On Failure
70 StructuredTaskScope – ShutDown On Success
71 Inheriting Scoped Values
72 Summary

Application Development With Spring & Virtual Threads
73 Introduction
74 External Services
75 Project Setup
76 DTO
77 Resource – RestClient
78 RestClient – Crash Course
79 Service Client
80 Trip Plan Service
81 Trip Reservation Service
82 Trip Controller
83 Resource – Application Properties
84 Application Properties
85 Service Client Beans
86 Executor Service Bean
87 Application Demo

Performance Testing With JMeter
88 Introduction
89 Throughput vs Response Time
90 Setting Up JMeter
91 Creating Test Script
92 Throughput vs Response Time – Demo
93 JConsole
94 VisualVM
95 HttpClient Executor
96 Best Practices
97 Resource – Test Scripts
98 Trip Reservation Test Script Creation
99 Trip Reservation Test With Platform Threads
100 Platform Threads Result Analysis
101 Virtual Threads Result Analysis
102 Rerunning Test With More Concurrent User Load
103 Trip Plan Test With Platform Threads
104 Trip Plan Test With Virtual Threads
105 Results Comparison
106 Summary

Whats next
107 Migration Guide For Existing Applications
108 What’s Next
109 Other Courses
110 Is Reactive Programming Dead

Homepage

Download from free file storage

Resolve the captcha to access the links!