Learning Path: Java: Delve Deep into Concurrency with Java 9

Course Curriculum

Chapter 1: Java 9 Concurrency – Basic Elements

Lecture 1: The Course Overview

Lecture 2: Creating, Running, and Setting the Characteristics of a Thread

Lecture 3: Interrupting a Thread

Lecture 4: Controlling the Interruption of a Thread

Lecture 5: Sleeping and Resuming a Thread

Lecture 6: Waiting for the Finalization of a Thread

Lecture 7: Creating and Running a Daemon Thread

Lecture 8: Processing Uncontrolled Exceptions in a Thread

Lecture 9: Using Thread Local Variables

Lecture 10: Grouping Threads and Processing Uncontrolled Exceptions in a Group of Threads

Lecture 11: Creating Threads Through a Factory

Lecture 12: Synchronizing a Method

Lecture 13: Using Conditions in Synchronized Code

Lecture 14: Synchronizing a Block of Code with a Lock

Lecture 15: Synchronizing Data Access with Read/Write Locks

Lecture 16: Using Multiple Conditions in a Lock

Lecture 17: Advanced Locking with the StampedLock Class

Lecture 18: Controlling Concurrent Access to One or More Copies of a Resource

Lecture 19: Waiting for Multiple Concurrent Events

Lecture 20: Synchronizing Tasks in a Common Point

Lecture 21: Running Concurrent-Phased Tasks

Lecture 22: Controlling Phase Change in Concurrent-Phased Tasks

Lecture 23: Exchanging Data Between Concurrent Tasks

Lecture 24: Completing and Linking Tasks Asynchronously

Chapter 2: Java 9 Concurrency – High-Level Elements

Lecture 1: The Course Overview

Lecture 2: Creating a Thread Executor and Controlling its Rejected Tasks

Lecture 3: Executing Tasks in an Executor that Returns a Result

Lecture 4: Running Multiple Tasks and Processing the First Result

Lecture 5: Running Multiple Tasks and Processing all the Results

Lecture 6: Running a Task in an Executor After a Delay

Lecture 7: Running a Task in an Executor Periodically

Lecture 8: Canceling a Task in an Executor

Lecture 9: Controlling a Task Finishing in an Executor

Lecture 10: Separating the Launching of Tasks and the Processing of their Results in an Exec

Lecture 11: Creating a Fork/Join Pool

Lecture 12: Joining the Results of the Tasks

Lecture 13: Running Tasks Asynchronously

Lecture 14: Throwing Exceptions in the Tasks

Lecture 15: Canceling a Task

Lecture 16: Creating Streams from Different Sources

Lecture 17: Reducing the Elements of a Stream

Lecture 18: Collecting the Elements of a Stream

Lecture 19: Applying an Action to Every Element of a Stream

Lecture 20: Filtering the Elements of a Stream

Lecture 21: Transforming the Elements of a Stream

Lecture 22: Sorting the Elements of a Stream

Lecture 23: Verifying Conditions in the Elements of a Stream

Lecture 24: Reactive Programming with Reactive Streams

Lecture 25: Using Non-Blocking Thread-Safe Deques

Lecture 26: Using Blocking Thread-Safe Deques

Lecture 27: Using Blocking Thread-Safe Queue Ordered by Priority

Lecture 28: Using Thread-Safe Lists with Delayed Elements

Lecture 29: Using Thread-Safe Navigable Maps

Lecture 30: Using Thread-Safe HashMaps

Lecture 31: Using Atomic Variables

Lecture 32: Using Atomic Arrays

Lecture 33: Using the Volatile Keyword

Lecture 34: Using Variable Handles

Chapter 3: Java 9 Concurrency- Advanced Elements

Lecture 1: The Course Overview

Lecture 2: Customizing the ThreadPoolExecutor Class

Lecture 3: Implementing a Priority –Based Executor Class

Lecture 4: Generate Custom Threads Using ThreadFactory Interface

Lecture 5: Using Our ThreadFactory in an Executor Object

Lecture 6: Customizing Tasks Running in a Scheduled Thread Pool

Lecture 7: Generating Custom Threads for the Fork/Join Framework

Lecture 8: Customizing Tasks Running in the Fork/Join Framework

Lecture 9: Implementing a Custom Lock Class

Lecture 10: Implementing a Transfer Queue-Based on Priorities

Lecture 11: Implementing Your Own Atomic Object

Lecture 12: Implementing Your Own Stream Generator

Lecture 13: Implementing Your Own Asynchronous Stream

Lecture 14: Monitoring a Lock Interface

Lecture 15: Monitoring a Phaser Class

Lecture 16: Monitoring an Executor Framework

Lecture 17: Monitoring a Fork/Join Pool

Lecture 18: Monitoring a Stream

Lecture 19: Writing Effective Log Messages

Lecture 20: Analyzing Concurrent Code with FindBugs

Lecture 21: Testing Concurrency Code with MultithreadedTC

Lecture 22: Monitoring with JConsole

Lecture 23: Using Atomic Variables Instead of Synchronization

Lecture 24: Holding Locks for as Short Time as Possible

Lecture 25: Delegating the Management of Threads to Executors

Lecture 26: Taking Precautions Using Lazy Initialization

Lecture 27: Using the Fork/Join Framework Instead of Executors

Lecture 28: Avoiding the Use of Blocking Operations Inside a Lock

Lecture 29: Using Streams to Process Big Data Sets