What you'll learn

Learn to manage the basic components of the Java Concurrency API
Use synchronization mechanisms to avoid data race conditions and other problems of concurrent applications
Separate thread management from the rest of the application with the Executor framework
Solve problems using a parallelized version of the divide-and-conquer paradigm with the Fork/Join framework
Practice efficient techniques to test concurrent applications

Course content

3 sections • 87 lectures • 7h 35m total length

The Course Overview3:09
This video provides an overview of the entire course
Creating, Running, and Setting the Characteristics of a Thread8:03
Build a class that implements the Runnable interface and the run method to create an object of the Thread class.
Interrupting a Thread4:21
Java provides an interruption mechanism that indicates to a thread that you want to finish it.
Controlling the Interruption of a Thread4:25
The thread implements a complex algorithm divided into some methods, or it has methods with recursive calls. Java provides the InterruptedException exception.
Sleeping and Resuming a Thread3:21
The thread doesn't use any resources of the computer.Use the sleep method of the Thread class.
Waiting for the Finalization of a Thread4:04
In some situations, we will have to wait for the end of the execution of a thread (the run() method ends its execution). We can use the join() method of the Thread class.
Creating and Running a Daemon Thread6:21
Java has a special kind of thread called daemon thread. Daemon threads are normally used as service providers for normal threads running in the same program.
Processing Uncontrolled Exceptions in a Thread3:49
The Java programming language, as almost all modern programming languages, implements an exception-based mechanism to manage error situations.
Using Thread Local Variables5:22
One of the most critical aspects of a concurrent application is shared data. This has a special importance in objects that extend the Thread class or implement the Runnable interface. The Java Concurrency API provides a clean mechanism called thread-local variables.
Grouping Threads and Processing Uncontrolled Exceptions in a Group of Threads3:44
An interesting functionality offered by the concurrency API of Java is the ability to group threads.Java provides the ThreadGroup class to work with a group of threads.
Creating Threads Through a Factory5:18
The factory pattern is one of the most used design patterns, and its objective is to develop an object whose mission is to create other objects of one or several classes. Java provides the ThreadFactory interface to implement a thread object factory.
Synchronizing a Method8:56
The most basic methods of synchronization in Java is the use of the synchronized keyword to control concurrent access to a method or a block of code
Using Conditions in Synchronized Code5:57
A classic problem in concurrent programming is the producer-consumer problem. We will implement the producer-consumer problem using thesynchronized keyword and the wait(), notify(), and notifyAll() methods.
Synchronizing a Block of Code with a Lock5:54
Java provides another mechanism for synchronizing blocks of code. It's based on the Lock interface and classes.
Synchronizing Data Access with Read/Write Locks5:44
One of the most significant improvements offered by locks is the ReadWriteLock interface and the ReentrantReadWriteLock class; the unique class that implements that interface.
Using Multiple Conditions in a Lock8:55
A classic problem in concurrent programming is the producer-consumer problem. We will implement the producer-consumer problem using locks and conditions.
Advanced Locking with the StampedLock Class6:27
The StampedLock class provides a special kind of lock that is different from the ones provided by the Lock or ReadWriteLock interfaces.
Controlling Concurrent Access to One or More Copies of a Resource6:17
The Java language provides the semaphore mechanism. A semaphore is a counter that protects access to one or more shared resources.
Waiting for Multiple Concurrent Events4:58
The Java concurrency API provides a class that allows one or more threads to wait until aset of operations are done. It's called the CountDownLatch class.
Synchronizing Tasks in a Common Point9:49
The Java concurrency API provides a synchronizing utility that allows the synchronization of two or more threads at a determined point. It's the CyclicBarrier class.
Running Concurrent-Phased Tasks9:35
One of the most complex and powerful functionalities offered by the Java concurrency API is the ability to execute concurrent-phased tasks using the Phaser class. This mechanism is useful when we have some concurrent tasks divided into steps.
Controlling Phase Change in Concurrent-Phased Tasks7:00
The Phaser class provides a method that is executed every time the phaser changes the phase,using the onAdvance() method.
Exchanging Data Between Concurrent Tasks5:13
The Java concurrency API provides a synchronization utility that allows the exchange of data between two concurrent tasks.The Exchanger class allows you to have adefinition of a synchronization point between two threads.
Completing and Linking Tasks Asynchronously8:48
The Java 8 Concurrency API includes a new synchronization mechanism with the CompletableFuture class. This class implements the Future object and the CompletionStage interface.
Java 9 Concurrency - Basic Elements

The Course Overview3:20
This video gives overview of the entire course.
Creating a Thread Executor and Controlling its Rejected Tasks9:36
When we want to finish the execution of an executor, we use the shutdown() method. The executor waits for the completion of tasks that are either running or waiting for their execution. The ThreadPoolExecutor class provides a mechanism, which is called when a task is rejected.
Executing Tasks in an Executor that Returns a Result6:04
One of the advantages of the Executor framework is that it allows you to run concurrent tasks that return a result. The Java Concurrency API achieves this with Callable and Future interfaces.
Running Multiple Tasks and Processing the First Result6:03
A common problem in concurrent programming arises when you have various concurrent tasks available to solve a problem. You have various sort of algorithms. You can launch all of them and get the result of the first one that sorts the array, that is, the fastest sorting algorithm for a given array.
Running Multiple Tasks and Processing all the Results5:29
When you want to wait for the finalization of a task, you can use the isDone() and awaitTermination() methods. These two methods have some drawbacks. The ThreadPoolExecutor class provides a method that allows you to send a list of tasks to the executor and wait for the finalization of all the tasks in the list.
Running a Task in an Executor After a Delay3:24
There are use cases when you are not interested in executing a task as soon as possible. You may want to execute a task after a period of time or do it periodically; the Executor framework provides the ScheduledExecutorService interface along with its implementation, namely, the ScheduledThreadPoolExecutor class.
Running a Task in an Executor Periodically5:48
The Executor framework provides the ThreadPoolExecutor class to execute concurrent tasks using a pool of threads that helps you avoid all thread creation operations.
Canceling a Task in an Executor4:12
When you want to cancel a task that you send to the executor, you can use the cancel() method of Future, which allows you to make the cancelation operation.
Controlling a Task Finishing in an Executor4:21
The Java API provides the FutureTask class as a cancelable asynchronous computation. It implements the Runnable and Future interfaces and provides the basic implementation of the Future interface.
Separating the Launching of Tasks and the Processing of their Results in an Exec6:58
When you execute concurrent tasks using an executor, you will send Runnable or Callable tasks to the executor and get Future objects to control the method. For such situations, the Java Concurrency API provides the CompletionService class.
Creating a Fork/Join Pool7:33
The basic elements of the fork/join framework are creating a ForkJoinPool object to execute the tasks and creating a subclass of ForkJoinTask to be executed in the pool.
Joining the Results of the Tasks8:00
The fork/join framework provides the ability to execute tasks that return a result.
Running Tasks Asynchronously5:53
In this video, you will learn how to use the asynchronous methods provided by the ForkJoinPool and CountedCompleter classes for the management of tasks.
Throwing Exceptions in the Tasks4:58
The behavior of the ForkJoinTask and ForkJoinPool classes is different. The program doesn't finish execution, and you won't see any information about the exception in the console. In this video, you will learn the techniques to get that information.
Canceling a Task8:43
When you execute the ForkJoinTask objects in a ForkJoinPool class, you can cancel them before they start their execution. The ForkJoinTask class provides the cancel() Method.
Creating Streams from Different Sources9:13
In this video, you will learn how to create streams from different sources.
Reducing the Elements of a Stream7:19
In this video, you will learn how to use the different versions of the reduce() method to generate a result from a stream of values.
Collecting the Elements of a Stream6:07
In this video, we will learn how to execute collect operations in Java streams with the different versions of the collect() method and the auxiliary Collectors class.
Applying an Action to Every Element of a Stream3:37
In this video, you will learn to apply an action to all the elements of the stream. We will use three methods: two terminal operations, the forEach() and forEachOrdered(), and an intermediate operation, the peek() method.
Filtering the Elements of a Stream3:06
One of the most commons actions you will apply to a stream will be the filtering operation that selects the elements that continue with the processing. In this recipe, you will learn the different methods provided by the Stream class to select the elements of a stream.
Transforming the Elements of a Stream5:01
Some of the intermediate operations that can be used with streams are those that allow you to transform the elements of the stream. In this video, you will learn to use the transforming intermediate operations.
Sorting the Elements of a Stream3:52
Another typical operation you will want to perform with a Stream is sorting its elements. You can speed up the execution by deleting the ordering constraint.
Verifying Conditions in the Elements of a Stream3:34
One interesting option provided by the Stream class is the possibility to check whether the elements of the stream verify a condition or not.
Reactive Programming with Reactive Streams6:06
Java 9 has included three interfaces: the Flow.Publisher, the Flow.Subscriber, and the Flow.Subscription, and a utility class, the SubmissionPublisher class, to allow us to implement reactive stream applications.
Using Non-Blocking Thread-Safe Deques4:09
A deque is a data structure similar to a queue, but you can add or remove elements from either the front (head) or back (tail) in a deque. In this video, you will learn how to use a non-blocking deque in a concurrent program.
Using Blocking Thread-Safe Deques2:14
The main difference between blocking deques and non-blocking deques is that blocking deques have methods to insert and delete elements that, if not done immediately. Java includes the LinkedBlockingDeque class that implements a blocking deque.
Using Blocking Thread-Safe Queue Ordered by Priority3:56
Another important characteristic of PriorityBlockingQueue is that it's a blocking data structure. It has methods that, if unable to perform the operation immediately, will block the thread until they are able to do it.
Using Thread-Safe Lists with Delayed Elements4:31
An interesting data structure provided by the Java API, which you can use in concurrent applications, is implemented in the DelayQueue class. In this program, we will learn to use the DelaydQueue class by storing in it some events with different activation dates.
Using Thread-Safe Navigable Maps4:47
The Java API provides a class that implements ConcurrentSkipListMap, which is the interface that implements a non-blocking list with the behavior of the ConcurrentNavigableMap interface.
Using Thread-Safe HashMaps5:01
A hash table is a data structure that allows you to map a key to a value. The Java API provides different hash table implementations through the Map and ConcurrentMap interfaces.
Using Atomic Variables3:51
Java introduced atomic variables. When a thread is performing an operation with an atomic variable and if other threads want to do an operation with the same variable, the implementation of the class includes a mechanism to check that the operation is done atomically.
Using Atomic Arrays4:09
Java introduced atomic arrays that provide atomic operations for arrays of integer or long numbers. In this video, you will learn to use the AtomicIntegerArray class to work with atomic arrays.
Using the Volatile Keyword3:26
In multithread applications, concurrent threads run in different CPUs or cores inside a CPU. To solve this problem, the Java language includes the volatile keyword.
Using Variable Handles3:12
Variable handles are a new feature of Java 9 that allow you to get a typed reference to a variable. You can use variable handles to obtain the same functionality without using any synchronization mechanism. A variable handle also allows you to get additional access modes to a variable.
Java 9 Concurrency - High-Level Elements

The Course Overview3:43
This video gives an overview of the entire course.
Customizing the ThreadPoolExecutor Class5:16
The executor uses one of its pooled threads or creates a new one to execute the tasks. It also decides the moment in which the task is executed.
Implementing a Priority –Based Executor Class4:10
With the Executor framework, you only have to implement your tasks and send them to the executor. The executor is responsible for the creation and execution of the threads that execute your tasks.
Generate Custom Threads Using ThreadFactory Interface3:48
Java provides theThreadFactory interface to implement a Thread object factory. Some advanced utilities of the Java concurrency API, such as the Executor framework or the fork/join framework, use thread factories to create threads.
Using Our ThreadFactory in an Executor Object2:08
The Executor framework is a mechanism that allows you to separate thread creation and its execution. It's based on the Executor and ExecutorService interfaces and the ThreadPoolExecutor class that implements both these interfaces.
Customizing Tasks Running in a Scheduled Thread Pool7:08
Scheduled thread pool is an extension of the basic thread pool of the Executor framework that allows you to schedule the execution of tasks to be executed after a period of time.
Generating Custom Threads for the Fork/Join Framework6:14
One of the most interesting features of Java 9 is the fork/join framework. It's an implementation of the Executor and ExecutorService interfaces that allows you to execute the Callable and Runnable tasks without managing the threads
Customizing Tasks Running in the Fork/Join Framework4:03
Java 9 provides a special kind of executor in the fork/join framework. The fork/join framework implements the work-stealing algorithm that improves the overall performance.
Implementing a Custom Lock Class4:48
In the Java Concurrency API, locks are declared in the Lock interface and implemented in some classes, for example, the ReentrantLock class
Implementing a Transfer Queue-Based on Priorities8:27
In this video, we will implement a data structure which is to be used in the producer / consumer problem; whose elements will be ordered by priority.
Implementing Your Own Atomic Object3:50
In this video, we will extend an atomic object and implement two operations that follow the mechanisms of the atomic objects to guarantee that all the operations are done in one step
Implementing Your Own Stream Generator6:47
Streams are based on the Stream interface and some related classes and interfaces included in the java.util.stream package. In this video, we will implement our own Spliterator interface and create a Stream interface to process its data
Implementing Your Own Asynchronous Stream7:23
Java 9 has included three interfaces--Flow.Publisher, Flow.Subscriber, and Flow.Subscription--and a utility class, SubmissionPublisher, to allow us to implement reactive stream applications.
Monitoring a Lock Interface4:26
A critical section is a block of code that accesses a shared resource and can't be executed by more than one thread at the same time. This mechanism is implemented by the Lock interface and the ReentrantLock class.
Monitoring a Phaser Class3:06
One of the most complex and powerful functionalities offered by the Java Concurrency API is the ability to execute concurrent-phased tasks using the Phaser class. This mechanism is useful when we have some concurrent tasks divided into steps.
Monitoring an Executor Framework3:18
The Executor framework provides a mechanism that separates the implementation of tasks from thread creation and management to execute the tasks.
Monitoring a Fork/Join Pool3:50
The Executor framework is designed to solve problems that can be broken down into smaller tasks using the fork() and join() operations. The main class that implements this behavior is ForkJoinPool.
Monitoring a Stream2:20
A stream in Java is a sequence of elements that could be processed either parallelly or sequentially in a pipeline of declarative operations using lambda expressions.
Writing Effective Log Messages5:59
A log system is a mechanism that allows you to write information to one or more destinations. In this video, we will use the classes provided by the java.util.logging package to add a log system to your concurrent application.
Analyzing Concurrent Code with FindBugs4:52
Static code analysis tools are a set of tools that analyze the source code of an application while looking for potential errors. The objective is to find errors or places that cause poor performance at an early stage, before they are executed in production.
Testing Concurrency Code with MultithreadedTC4:47
MultithreadedTC is a Java library for testing concurrent applications. it includes an internal metronome. These testing threads are implemented as methods of a class.
Monitoring with JConsole3:34
JConsole is a monitoring tool that follows the JMX specification that allows you to get information about the execution of an application as the number of threads, memory use, or class loading. In this video, we will use this tool to monitor a simple concurrent application
Using Atomic Variables Instead of Synchronization5:06
Some classes of the java.util.concurrent package use atomic variables instead of synchronization. In this video, you will develop an example that shows how an atomic attribute provides better performance than synchronization.
Holding Locks for as Short Time as Possible4:37
Locks allow the definition of a critical section that only one thread can execute at a time. In this video, we will implement an example to see the difference in the performance of a task with a long operation inside the critical section and a task with a long operation outside the critical section.
Delegating the Management of Threads to Executors2:12
The use of executors has a lot of advantages over direct utilization of threads. In this video, we will implement an example that shows how you can obtain better performance using an executor than creating the threads yourself.
Taking Precautions Using Lazy Initialization3:45
Lazy initialization is a common programming technique that delays object creation until it is needed for the first time. In this video, we will implement an elegant solution to the lazy initialization problem
Using the Fork/Join Framework Instead of Executors4:43
Java 7 provides a new kind of executor with the fork/join framework. This executor, implemented in the ForkJoinPool class, is designed for problems that can be split into smaller parts using the divide and conquer technique. For these kinds of problems, fork/join pools get better performance than classical executors.
Avoiding the Use of Blocking Operations Inside a Lock2:52
Blocking operations are operations that block the execution of the current thread until an event occurs. Typical blocking operations are those that involve input or output operations with the console, a file, or network. The threads read a line from the console inside the critical section. This instruction makes the rest of the threads of the application will be blocked until the user introduces the line.
Using Streams to Process Big Data Sets5:04
A Stream interface is a sequence of elements that can be filtered and transformed to get a final result sequentially or in parallel. In this video, we will process big data sets using streams.
Java 9 Concurrency – Advance Elements

Requirements

Java programming knowledge is needed

Description

Writing concurrent and parallel programming applications is a must-have skill for any Java programmer. Java 9 comes with a host of fantastic features, including significant performance improvements and new APIs. So, if you're familiar with the basics of Java and want to understand concurrency and parallel programming techniques, then go for this Learning Path.

Packt’s Video Learning Paths are a series of individual video products put together in a logical and stepwise manner such that each video builds on the skills learned in the video before it.

The highlights of this Learning Path are:

Practical examples on thread safety, high-performance classes, safe sharing, and much more
Understand Java 9 APIs and their impact on concurrency

Let's take a look at your learning journey. You will know the elements of the Java concurrency API that will help you take advantage of the exciting new capabilities. You will learn how to use parallel and reactive streams to process massive data sets. Next, you will move on to create streams and use all their intermediate and terminal operations to process big collections of data in a parallel and functional way. Moving ahead, you’ll discover a whole range of recipes for almost everything, such as thread management, synchronization, executors, parallel and reactive streams, and much more. By the end of this Learning Path, you will be able to deploy scalable and concurrent application

Meet Your Expert:

We have the best works of the following esteemed author to ensure that your learning journey is smooth:

Javier Fernández González is a software architect with almost 15 years experience in Java technologies. He has worked as a teacher, researcher, programmer, analyst, and writer, and he now works as an architect in all types of projects related to Java, especially J2EE. As a teacher has over 1,000 hours of training in basic Java, J2EE, and the Struts framework. As a researcher, he has worked in the field of information retrieval, developing applications for processing large amounts of data in Java, and has participated as a co-author in several journal articles and conference presentations. Recently, he worked on developing J2EE web applications for various clients from different sectors (public administration, insurance, healthcare, transportation, and so on). He has also worked as a software architect. He is the author of the books, Java 7 Concurrency Cookbook and Mastering Concurrency Programming with Java 8 by Packt Publishing.

Who this course is for:

This Learning Path is targeted at developers who are familiar with Java programming and want to gain the skills of building highly-scalable, robust, and concurrent applications.

What you'll learn

Explore related topics

Course content

Java 9 Concurrency - Basic Elements24 lectures • 2hr 26min

Java 9 Concurrency - High-Level Elements34 lectures • 2hr 58min

Java 9 Concurrency- Advanced Elements29 lectures • 2hr 12min

Requirements

Description

Who this course is for: