Pluralsight - Scaling Java Applications Through Concurrency

Pluralsight - Scaling Java Applications Through Concurrency
Pluralsight - Scaling Java Applications Through Concurrency
MPEG-4 | English | 1280 x 720 | 148 kb/s | 15.000 fps | AAC 66.2 kb/s | 497.23 MB
Genre: Training

Distributed systems and multi-core platforms are far too prevalent now to dismiss everyday concurrency. This course outlines several concurrency patterns that the Java Concurrency API simplifies, making it much easier to scale your Java application.

There are several gems inside the existing concurrency API that have been hiding in the background for years, waiting to be discovered by curious software engineers. The existing Java Concurrency API makes it much easier to build a Java application that is scalable and performant without having to settle for lots of low-level wait-notify usage or lots of locking using the synchronized keyword. In this course, Scaling Java Applications Through Concurrency, you'll cover several concurrency patterns simplified by the Java Concurrency API; these patterns will make scaling new and existing Java applications simpler than ever. First, you'll learn about how the Java Concurrency API has changed scalability and how to run processes in the background. Next, you'll cover classes that will help you avoid mistakes like lost updates when sharing resources. Finally, you'll discover how to coordinate dependent processes and implementing throttling. By the end of this course, you will be able to easily scale your Java applications through concurrency so that they work better and faster.

Course Outline

The End of Moore's Law
Patterns Over Primitives 4m 59s

Running Processes in the Background
The Fire-and-Forget Pattern 3m 14s
Introducing ThreadPoolExecutor 3m 54s
Implementing Fire-and-Forget Using ThreadPoolExecutor 6m 36s
Introducing ForkJoinPool 1m 49s
Implementing Fire-and-Forget Using ForkJoinPool 0m 59s
Introducing Threaded Recursion with ForkJoinPool and BlockingQueue 2m 2s
Implementing Fire-and-Forget Using Threaded Recursion 3m 42s
Conclusion 0m 42s

Sharing Resources Among Parallel Workers
Introduction 0m 29s
The Scatter-Gather Pattern 2m 28s
Scatter-Gather Using Futures 3m 25s
Scatter-Gather Using ExecutorService 3m 46s
ExecutorService vs. ExecutorCompletionService Performance 1m 55s
The Importance of Making Aggregations Thread-safe 2m 44s
Gathering Using Concurrency Primitives 4m 18s
Gathering Using AtomicInteger, ConcurrentHashMap, and LongAdder 3m 31s
Gathering Using ReentrantLock 4m 5s
Max Search Using TryLock 3m 18s
Conclusion 1m 19s

Coordinating Efforts Among Dependent Processes
Introduction 0m 45s
Dependency Choreography Using CountDownLatch 3m 11s
Implementing Dependency Choreography Using CountDownLatch 3m 13s
Dependency Choreography Using Continuation-passing 5m 23s
Implementing Dependency Choreography Using Continuation-Passing 17m 5s
Dependency Choreography Using CompletableFuture 2m 57s
Implementing Dependency Choreography Using CompletableFuture 6m 8s
Addressing Thread Contention Using Thread Pools 2m 45s
Conclusion 0m 57s

Throttling Incoming Work
Introduction 2m 53s
Throttling Using ThreadPoolExecutor 2m 30s
Implementing Throttling Using ThreadPoolExecutor 6m 40s
Throttling Using Semaphore 2m 19s
Implementing Throttling Using Semaphore 3m 53s
Throttling Using CyclicBarrier 3m 24s
Implementing Throttling Using CyclicBarrier 6m 4s
Throttling Using Phaser 2m 30s
Implementing Throttling Using Phaser 4m 37s
Performance Metrics Breakdown 1m 44s
Conclusion 1m 4s

Buy Premium From My Links To Get Resumable Support,Max Speed & Support Me

Alternate Link for Pluralsight - Scaling Java Applications Through Concurrency.rar When above links are dead

Hello Respective Visitor!

Please Login or Create a FREE Account to gain accesss to hidden contents.


Would you like to leave your comment? Please Login to your account to leave comments. Don't have an account? You can create a free account now.