Advanced Java Concurrent Patterns

Concurrency is a hard to master topic. This Java course takes you from the basics you already know, (runnable and synchronization) to the next level: the java.util.concurrent API.
Course info
Rating
(130)
Level
Advanced
Updated
Mar 13, 2017
Duration
3h 29m
Table of contents
Course Overview
Introducing the Executor Pattern, Futures and Callables
Using Locks and Semaphores for the Producer / Consumer Pattern
Controlling Concurrent Applications Using Barriers and Latches
Understanding Casing and Atomic Variables
Leveraging Concurrent Collections to Simplify Application Design
Introduction, Module Agenda 1m Implementing Concurrency at the API Level 1m Hierarchy of Collection and Map, Concurrent Interfaces 1m What Does It Mean for an Interface to Be Concurrent? 1m Why You Should Avoid Vectors and Stacks 1m Understanding Copy On Write Arrays 2m Wrapping up CopyOnWriteArrayList 2m Introducing Queue and Deque, and Their Implementations 2m Understanding How Queue Works in a Concurrent Environment 2m Adding Elements to a Queue That Is Full: How Can It Fail? 2m Understanding Error Handling in Queue and Deque 2m Wrapping up Queue, Deque, and Their Blocking Versions 1m Introducing Concurrent Maps and Their Implementations 1m Atomic Operations Defined by the ConcurrentMap Interface 2m Understanding Concurrency for a HashMap 3m Understanding the Structure of the ConcurrentHashMap from Java 7 2m Introducing the Java 8 ConcurrentHashMap and Its Parallel Methods 1m Parallel Search on a Java 8 ConcurrentHashMap 1m Parallel Map / Reduce on a Java 8 ConcurrentHashMap 1m Parallel ForEach on a Java 8 ConcurrentHashMap 1m Creating a Concurrent Set on a Java 8 ConcurrentHashMap 1m Wrapping up the Java 8 ConcurrentHashMap 1m Introducing Skip Lists to Implement ConcurrentMap 1m Understanding How Linked Lists Can Be Improved by Skip Lists 3m Wrapping up the Skip List Structure 1m How to Make a Skip List Concurrent Without Synchronization 1m Wrapping up ConcurrentSkipList 1m Live Coding: Producer / Consumer Built on an ArrayBlockingQueue 3m Live Coding: Parallel Reduce in Action on a ConcurrentHashMap 3m Live Coding: Parallel Search in Action on a ConcurrentHashMap 2m Live Coding: Computing an Average on a ConcurrentHashMap 1m Live Coding Wrap-up 1m Module Wrap-up 2m Course Wrap-up 1m
Description
Course info
Rating
(130)
Level
Advanced
Updated
Mar 13, 2017
Duration
3h 29m
Description

This course, Advanced Java Concurrent Patterns is an in-depth presentation of advanced fundamentals you'll need to understand to write efficient concurrent applications, that support heavy concurrency and provide high throughput. You'll learn about how you can improve the quality of your concurrent code, by using sophisticated concurrent tools that allow for smooth lock acquisition and fault tolerancy. You'll also be introduced to advanced data structures, such as the copy on write arrays, the concurrent blocking queues, the concurrent skip lists and concurrent hashmaps. By the end of this course, you will understand how to use cyclic barriers, count down latches and semaphores, and how to atomic variables to write non-locking code. All of this will help you on your journey to write better applications.

About the author
About the author

Passionate about programming computers for over 20 years, Jose made his debut in assembler and C, C for SIMD parallel machines before adopting Java as an object-oriented language. Assistant professor in Paris North University for more than 15 years, Jose also brings his expertise to many projects, in various industrial fields.

More from the author
More courses by Jose Paumard
Section Introduction Transcripts
Section Introduction Transcripts

Course Overview
Hi everyone. My name is Jose. Welcome to my course, Advanced Java Concurrent Patterns. I am talking to you from Paris where I am an assistant professor, as well as a speaker at various Java conferences, Java 1 in San Francisco, and Dev Ops here in Europe just to name a few. I know how scary the title of this course might look, but don't be afraid. I'll take you through it step by step. We will see the patterns, how things can go wrong, and how to deal with the situation. If you follow me, at the end of this course, you will have a good idea of the ExecutorService Patterns and callables, and futures, what is interruptible or timed out lock acquisition, what are logs, semaphores, barriers, and latches, and what is CASing, and atomic variables. And at last, we will see the concurrent collections, copy and write release, concurrent hashmaps, and concurrent skip lists. But before you move on, you would like to be familiar with the Java language and the collection API. You also need some knowledge of concurrency and be able to write basic lambda expressions. For that, you can check the Pluralsight library for Java courses on those topics. Yes, this is an ambitious ride, but don't be afraid. Just let me guide you through all this, and you will see that from the other side, concurrencies, in fact, not that scary.