Advanced Java Concurrent Patterns

—Introduction, Module Agenda 1m 33s
—What Is Wrong with Intrinsic Locking and Synchronization? 2m 15s
—Introducing API Locking with the Lock Interface 1m 55s
—Differences Between Synchronization and API Locking 0m 56s
—Lock Patterns: Interruptible Lock Acquisition 1m 22s
—Lock Patterns: Timed Lock Acquisition 1m 1s
—Lock Patterns: Fair Lock Acquisition 1m 43s
—Wrapping-up the Lock Pattern 1m 5s
—Producer / Consumer Pattern: Wait / Notify Implementation 2m 30s
—Producer / Consumer Pattern: Lock Implementation with Condition 1m 55s
—The Condition Object: Interruptibility and Fairness 2m 22s
—Wrapping-up the Lock and Condition Objects 0m 33s
—Introducing the ReadWriteLock Pattern 2m 11s
—Implementing an Efficient Concurrent Cache with ReadWriteLock 1m 44s
—Wrapping-up the ReadWriteLock Pattern 1m 3s
—Introducing the Semaphore Pattern, First Example 2m 19s
—Semaphore Pattern: Interruptibility and Timed Permit Acquisition 1m 41s
—Wrapping-up the Semaphore Pattern, Control of the Waiting Threads 1m 45s
—Live Coding: Producer / Consumer Based on the Lock Pattern 3m 24s
—Live Coding: Setting up Conditions on the Producer / Consumer 3m 47s
—Live Coding: Setting up the Right Number of Threads 2m 32s
—Live Coding: Dealing with Exceptions with Timeouts 2m 25s
—Live Coding: Setting up Timeout to Unlock a Producer / Consumer 1m 44s
—Live Coding: Creating a Cache with a Race Condition on HashMap 2m 42s
—Live Coding: Fixing the HashMap Cache with ReadWriteLock 2m 43s
—Live Coding Wrap-up 1m 37s
—Module Wrap-up 1m 14s

—Introduction, Module Agenda 1m 15s
—Sharing a Task Among Threads and Merging the Results 1m 37s
—The Problem of Synchronizing on the End of Tasks 1m 26s
—Creating Callable Tasks and Setting up a Barrier 1m 18s
—Understanding the CyclicBarrier Pattern 2m 3s
—Setting up the Full CyclicBarrier Pattern and Launching Tasks 1m 12s
—Waiting for the Barrier with a Time out, Dealing with Exception 1m 45s
—Wrapping-up the CyclicBarrier 1m 13s
—Introducing the Latch, a Barrier That Cannot Be Reset 1m 54s
—Understanding the CountDownLatch Pattern 0m 48s
—A CountDownLatch in Action to Start an Application 2m 13s
—Wrapping-up the CountDownLatch Pattern 0m 39s
—Live Coding: A CyclicBarrier with a Callback Task in Action 3m 14s
—Live Coding: Setting up the ExecutorService, Using TimeOut 3m 51s
—Live Coding: Using Future TimeOut and Task Cancellation 3m 1s
—Live Coding Wrap-up 0m 57s
—Module Wrap-up 1m 15s

—Introduction, Module Agenda 1m 21s
—Understanding Casing: Do We Always Need Synchronization? 2m 17s
—Understanding Casing: An Example of False Concurrency 1m 46s
—Understanding Casing: How Does It Work? 2m 17s
—How to Use the AtomicLong Class and How Does It Work 1m 52s
—The Java Atomic API: The AtomicBoolean Class 1m 13s
—The Java Atomic API: The AtomicInteger and AtomicLong Classes 1m 53s
—The Java Atomic API: The AtomicReference Class 1m 13s
—Wrapping-up the Atomic Objects 1m 54s
—Understanding Adders and Accumulators 1m 33s
—Browsing Through the Adder and Accumulator API 2m 6s
—Live Coding: Fixing a Race Condition on a Simple Counter 3m 20s
—Live Coding: Counting the Number of Retries in an AtomicInteger 4m 0s
—Live Coding Wrap-up 1m 0s
—Module Wrap-up 1m 39s

—Introduction, Module Agenda 1m 12s
—Implementing Concurrency at the API Level 1m 17s
—Hierarchy of Collection and Map, Concurrent Interfaces 1m 19s
—What Does It Mean for an Interface to Be Concurrent? 1m 16s
—Why You Should Avoid Vectors and Stacks 1m 29s
—Understanding Copy On Write Arrays 1m 59s
—Wrapping up CopyOnWriteArrayList 1m 33s
—Introducing Queue and Deque, and Their Implementations 2m 0s
—Understanding How Queue Works in a Concurrent Environment 1m 42s
—Adding Elements to a Queue That Is Full: How Can It Fail? 2m 17s
—Understanding Error Handling in Queue and Deque 1m 47s
—Wrapping up Queue, Deque, and Their Blocking Versions 0m 52s
—Introducing Concurrent Maps and Their Implementations 0m 55s
—Atomic Operations Defined by the ConcurrentMap Interface 1m 54s
—Understanding Concurrency for a HashMap 2m 45s
—Understanding the Structure of the ConcurrentHashMap from Java 7 2m 28s
—Introducing the Java 8 ConcurrentHashMap and Its Parallel Methods 0m 55s
—Parallel Search on a Java 8 ConcurrentHashMap 1m 3s
—Parallel Map / Reduce on a Java 8 ConcurrentHashMap 0m 48s
—Parallel ForEach on a Java 8 ConcurrentHashMap 1m 12s
—Creating a Concurrent Set on a Java 8 ConcurrentHashMap 0m 51s
—Wrapping up the Java 8 ConcurrentHashMap 0m 35s
—Introducing Skip Lists to Implement ConcurrentMap 1m 6s
—Understanding How Linked Lists Can Be Improved by Skip Lists 2m 53s
—Wrapping up the Skip List Structure 0m 50s
—How to Make a Skip List Concurrent Without Synchronization 1m 16s
—Wrapping up ConcurrentSkipList 0m 41s
—Live Coding: Producer / Consumer Built on an ArrayBlockingQueue 3m 11s
—Live Coding: Parallel Reduce in Action on a ConcurrentHashMap 3m 24s
—Live Coding: Parallel Search in Action on a ConcurrentHashMap 1m 48s
—Live Coding: Computing an Average on a ConcurrentHashMap 1m 22s
—Live Coding Wrap-up 1m 2s
—Module Wrap-up 2m 21s
—Course Wrap-up 1m 2s