Java 26: Virtual Threads, Concurrency Masterclass [Hands-On]
Multithreading, Structured Concurrency, Executorservice, ScopedValues, CompletableFuture, Scalability with Spring Boot
Lo que serás capaz de hacer
Up-to-date with JDK/Java 26: This course covers all the latest Java features, including finalized Scoped Values, the latest preview of Structured Concurrency (JEP 505), and the foundational power of Virtual Threads. Master modern, high-performance Java concurrency and build applications that scale effortlessly. This course takes you from foundational Multithreading concepts to the cutting edge of Virtual Threads , Structured Concurrency , and Scoped Values , all reinforced with hands-on Spring Boot projects. Course Highlights: Understanding Concurrency : Start with the basics. Understand platform threads , their lifecycle, and the challenges of traditional concurrency. Learn why scaling with conventional threads is difficult and how Java Virtual Threads provide a lightweight, high-performance alternative for handling thousands of concurrent tasks efficiently. ExecutorService Mastery : Dive into ExecutorService and see how it works with both platform threads and virtual threads. Learn to manage concurrency, execute tasks in parallel, and optimize thread usage for scalable applications. CompletableFuture Integration : Explore CompletableFuture for asynchronous task execution with Virtual Threads. Learn practical patterns for chaining tasks, handling exceptions, and managing timeouts in a clean, declarative way. ThreadLocal and Scoped Values : Understand ThreadLocal for storing thread-specific context and the challenges it poses. Then explore Scoped Values , the modern alternative that works seamlessly with both platform and virtual threads, avoids memory leaks, and simplifies context propagation. Structured Concurrency : Get a hands-on introduction to Java’s Structured Concurrency APIs , learning how to manage groups of tasks as a single unit, improve reliability, and simplify lifecycle management of concurrent tasks. Hands-On Application Development : Apply your knowledge in a Spring Boot Web project using Virtual Threads. Learn how these concurrency concepts integrate into real-world application development. Performance Testing with JMeter : Test the scalability of your application using JMeter , measuring throughput and response times to ensure optimal efficiency under various workloads. 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. Don't just learn concurrency. Master the future of high-performance Java. Unlock the full potential of Virtual Threads, Structured Concurrency, and Scoped Values to design the most scalable, efficient, and modern applications on the platform.
- Master Virtual Threads (Project Loom): Learn how to effectively use Virtual Threads to improve the performance and scalability of your Java applications.
- Structured Concurrency (JEP 505): Implement Structured Concurrency for predictable task cancellation, simple error handling, and clear task scopes.
- Scoped Values vs. ThreadLocal: Learn Scoped Values (JEP 506) to safely share immutable context across threads, replacing the old ThreadLocal pattern
- Advanced Async CompletableFuture: Compose complex flows with CompletableFuture while guaranteeing robust error recovery in Virtual Thread apps
- JDK 26 Feature Adoption: Get practical guidance on adopting Java 26's finalized APIs, focusing on Scoped Values and Structured Concurrency patterns. (
- JMeter Performance Testing: Validate gains with rigorous load testing and scalability testing of your high-concurrency Java apps.
Temario
UNIDAD 1 - Getting Started · 1 leccionesUNIDAD 1 - Getting Started
UNIDAD 1 - Getting Started
- Before You Enroll...
UNIDAD 2 - Virtual Thread Fundamentals · 27 leccionesUNIDAD 2 - Virtual Thread Fundamentals
UNIDAD 2 - Virtual Thread Fundamentals
- Need For Virtual Threads
- *** Resources ***
- Project Setup
- Demo: Platform Thread Limits
- Creating Virtual Threads: The Thread Builder
- Demo: Virtual Thread Scaling
- How Virtual Threads Work Internally
- Demo: The Carrier Thread
- Virtual Thread & Stack
- OPTIONAL: Diagnosing Stack Traces
- CPU-Bound Tasks: Part 1
- CPU-Bound Tasks: Part 2
- CPU-Bound Tasks: Part 3
- Virtual Thread - Scheduler Config
- Preemptive vs Cooperative Scheduling
- Demo: Cooperative Scheduling
- How Virtual Thread Can Help?
- Concurrency: Synchronization Basics
- OPTIONAL: Synchronization in Compute Tasks
- Thread Pinning: Demo
- Thread Pinning: When & Why it Matters
- Diagnosing Pinning: How to Trace
- Fixing Pinning: The ReentrantLock Solution
- Advanced Creation: Virtual Thread Factory
- OPTIONAL: Key Thread Methods Review
- Section Summary and Key Takeaways
- Virtual Threads Challenge
UNIDAD 3 - Executors and Virtual Threads · 25 leccionesUNIDAD 3 - Executors and Virtual Threads
UNIDAD 3 - Executors and Virtual Threads
- ExecutorService: Introduction
- ExecutorService: The Different Types
- Executors and AutoCloseable
- Demo: Comparing Executor Service Types
- ** Resource ** - External Service
- External Service
- Creating the External Service Client
- Accessing Responses Using Future
- OPTIONAL: Concurrency vs Parallelism
- The Future Interface: Useful Methods
- Building the Aggregator Service
- Do We Create Extra Thread?
- Clarification: Virtual Thread Executor Behavior
- Executors with Virtual Thread Factory
- Challenges with Executors & Virtual Threads
- The Need For Concurrency Limit
- Semaphore
- Building The Virtual Thread Concurrency Limiter
- Concurrency Limits: Managing Order
- Virtual Thread Concurrency Limiter With Order
- ScheduledExecutorService with Virtual Threads
- Stream Gatherers: Concurrent Mapping
- Stream Gatherers: What About Nested Concurrent Calls?
- Section Summary and Key Takeaways
- ExecutorService Challenge
UNIDAD 4 - Asynchronous Programming with CompletableFuture · 13 leccionesUNIDAD 4 - Asynchronous Programming with CompletableFuture
UNIDAD 4 - Asynchronous Programming with CompletableFuture
- CompletableFuture: Introduction
- CompletableFuture: Internal Mechanics
- Demo: Basic CompletableFuture
- Async Tasks: runAsync()
- Async Tasks: supplyAsync()
- Practical Example: Fetching Product Info
- CompletableFuture: Error Handling
- CompletableFuture: Handling Timeouts
- Combining Futures: allOf()
- Combining Futures: anyOf()
- Combining Futures: thenCombine()
- Section Summary and Key Takeaways
- CompletableFuture Assessment
UNIDAD 5 - Thread Local & Scoped Values · 17 leccionesUNIDAD 5 - Thread Local & Scoped Values
UNIDAD 5 - Thread Local & Scoped Values
- ThreadLocal: Introduction & Basics
- Demo: ThreadLocal Usage
- InheritableThreadLocal: When to Use
- ThreadLocal Limitations & Golden Rules
- ThreadLocal Workflow: Implementation (Part 1)
- ThreadLocal Workflow: Implementation (Part 2)
- Demo: ThreadLocal Workflow in Action
- Scoped Values: Introduction & Basics
- Demo: Scoped Value Usage
- Assignment: Applying Scoped Values
- Scoped Values: Rebinding & Immutability
- Scoped Values: How It Works Internally
- Scoped Values Workflow: Implementation
- Scoped Values In Action: Run As Administrator
- ThreadLocal vs Scoped Values
- Section Summary and Key Takeaways
- Quiz
UNIDAD 6 - Java Concurrency Interview Prep · 1 leccionesUNIDAD 6 - Java Concurrency Interview Prep
UNIDAD 6 - Java Concurrency Interview Prep
- Java Concurrency Job Interview
UNIDAD 7 - Structured Concurrency (JEP 505) · 5 leccionesUNIDAD 7 - Structured Concurrency (JEP 505)
UNIDAD 7 - Structured Concurrency (JEP 505)
- Structured Concurrency: Introduction
- Scope Policies: Wait For All
- Scope Policies: Fail-Fast (All Successful)
- Scope Policies: First Success (Any Successful)
- Scoped Values: Automatic Propagation
UNIDAD 8 - Final Project: Virtual Threads in Real-World Applications · 15 leccionesUNIDAD 8 - Final Project: Virtual Threads in Real-World Applications
UNIDAD 8 - Final Project: Virtual Threads in Real-World Applications
- Project Introduction & Goals
- Defining External Services
- Setting Up the Spring Project
- Data Transfer Objects (DTOs)
- ** Resource ** - RestClient
- RestClient: Quick Start
- Building the Service Client
- Implementing Trip Plan Service
- Implementing Trip Reservation Service
- Implementing Trip Controller
- Resource: Application Properties File
- Configuring Application Properties
- Spring Beans: Service Clients
- Spring Beans: ExecutorService Configuration
- Final Application Demo & Testing
UNIDAD 9 - Performance Testing With JMeter · 19 leccionesUNIDAD 9 - Performance Testing With JMeter
UNIDAD 9 - Performance Testing With JMeter
- Introduction
- Throughput vs Response Time
- Setting Up JMeter
- Creating Test Script
- Throughput vs Response Time - Demo
- JConsole
- VisualVM
- HttpClient Executor
- Best Practices
- ** Resource ** - Test Scripts
- Trip Reservation Test Script Creation
- Trip Reservation Test With Platform Threads
- Platform Threads Result Analysis
- Virtual Threads Result Analysis
- Rerunning Test With More Concurrent User Load
- Trip Plan Test With Platform Threads
- Trip Plan Test With Virtual Threads
- Results Comparison
- Summary
UNIDAD 10 - Whats next? · 4 leccionesUNIDAD 10 - Whats next?
UNIDAD 10 - Whats next?
- Migration Guide For Existing Applications
- What's Next?
- Other Courses
- Is Reactive Programming Dead?
Tu certificado lo emite la SEP, no solo una plataforma
Al demostrar la competencia recibes un certificado emitido por la Secretaría de Educación Pública a través del Gobierno del Estado de México: un documento oficial que puedes presentar con confianza ante cualquier empleador o institución.
Tu certificado con INEC
- Lo emite la Secretaría de Educación Pública (SEP), a través del Gobierno del Estado de México
- Documento oficial con folio verificable en línea
- Lo otorga la Universidad Tecnológica Fidel Velázquez
Otras plataformas en línea
- Constancia privada emitida por la misma plataforma
- Solo acredita horas cursadas o asistencia
- Sin respaldo de una autoridad educativa
Tu itinerario, de la inscripción al certificado
- 1
Inscripción con pago único
Pagas $2,800 MXN una sola vez y entras de inmediato al curso.
- 2
Estudias a tu ritmo
10 unidades con videos, lecturas y actividades, disponibles 24/7 durante 12 meses.
- 3
Cuestionarios por unidad
4 cuestionarios para comprobar lo aprendido.
- 4
Certificado
Emitido por la SEP a través del Gobierno del Estado de México, con folio verificable.
Un certificado oficial de la SEP
![Muestra del certificado: Java 26: Virtual Threads, Concurrency Masterclass [Hands-On]](https://www.institutoimec.edu.mx/wp-content/uploads/inec-landing/certificado-muestra.jpg)
Muestra · verificable por folio y QR
- Emitido por la Secretaría de Educación Pública (SEP), a través del Gobierno del Estado de México. No es una constancia privada: es un documento oficial, y ese respaldo marca la diferencia frente a otras plataformas en línea.
- Contenido impartido por Vinoth Selvaraj.
- Folio y QR verificables para compartirlo con quien te contrate.
Empieza hoy, a tu ritmo
Un solo pago y acceso inmediato al curso completo durante 12 meses.
- 10 unidades · 127 lecciones · 50 h
- 12 meses de acceso
- 4 cuestionarios de evaluación
- Certificado emitido por la SEP (Gob. del Estado de México) con folio verificable
Sobre tu inscripción
¿Cómo es el pago?
Un solo pago de $2,800 MXN. No hay mensualidades ni cargos recurrentes.
¿Cuánto tiempo tengo acceso?
12 meses desde tu inscripción, 24/7, para avanzar a tu ritmo.
¿Quién imparte el contenido?
El curso es impartido por Vinoth Selvaraj; INEC gestiona tu inscripción, evaluación y certificado.
¿Qué pasa cuando vence mi acceso?
Puedes renovar tu cuenta tú mismo desde la plataforma, sin trámites ni esperas.
