Book Image

Java 9 Concurrency Cookbook, Second Edition - Second Edition

By : Javier Fernández González
Book Image

Java 9 Concurrency Cookbook, Second Edition - Second Edition

By: Javier Fernández González

Overview of this book

Writing concurrent and parallel programming applications is an integral skill for any Java programmer. Java 9 comes with a host of fantastic features, including significant performance improvements and new APIs. This book will take you through all the new APIs, showing you how to build parallel and multi-threaded applications. The book covers all the elements of the Java Concurrency API, with essential recipes 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. Further, you’ll discover a whole range of recipes for almost everything, such as thread management, synchronization, executors, parallel and reactive streams, and many more. At the end of the book, you will learn how to obtain information about the status of some of the most useful components of the Java Concurrency API and how to test concurrent applications using different tools.

Related Content you might be interested in

Current Title:

Small book image
Java 9 Concurrency Cookbook, Second Edition - Second Edition
Javier Fernández González
Apr, 2017 | 594 pages
Small book image
Mastering Concurrency Programming with Java 9
Javier Fernández González
Jul, 2017 | 516 pages
Small book image
Java Coding Problems
Anghel Leonard
Sep, 2019 | 816 pages
Small book image
Concurrent Patterns and Best Practices
Atul S Khot
Sep, 2018 | 264 pages
Table of Contents (12 chapters)
Preface
Preface
What this book covers
What you need for this book
Who this book is for
Sections
Conventions
Reader feedback
Customer support
Free Chapter
1
Thread Management
Thread Management
Introduction
Creating, running, and setting the characteristics of a thread
Interrupting a thread
Controlling the interruption of a thread
Sleeping and resuming a thread
Waiting for the finalization of a thread
Creating and running a daemon thread
Processing uncontrolled exceptions in a thread
Using thread local variables
Grouping threads and processing uncontrolled exceptions in a group of threads
Creating threads through a factory
2
Basic Thread Synchronization
Basic Thread Synchronization
Introduction
Synchronizing a method
Using conditions in synchronized code
Synchronizing a block of code with a lock
Synchronizing data access with read/write locks
Using multiple conditions in a lock
Advanced locking with the StampedLock class
3
Thread Synchronization Utilities
Thread Synchronization Utilities
Introduction
Controlling concurrent access to one or more copies of a resource
Waiting for multiple concurrent events
Synchronizing tasks in a common point
Running concurrent-phased tasks
Controlling phase change in concurrent-phased tasks
Exchanging data between concurrent tasks
Completing and linking tasks asynchronously
4
Thread Executors
Thread Executors
Introduction
Creating a thread executor and controlling its rejected tasks
Executing tasks in an executor that returns a result
Running multiple tasks and processing the first result
Running multiple tasks and processing all the results
Running a task in an executor after a delay
Running a task in an executor periodically
Canceling a task in an executor
Controlling a task finishing in an executor
Separating the launching of tasks and the processing of their results in an executor
5
Fork/Join Framework
Fork/Join Framework
Introduction
Creating a fork/join pool
Joining the results of the tasks
Running tasks asynchronously
Throwing exceptions in the tasks
Canceling a task
6
Parallel and Reactive Streams
Parallel and Reactive Streams
Introduction
Creating streams from different sources
Reducing the elements of a stream
Collecting the elements of a stream
Applying an action to every element of a stream
Filtering the elements of a stream
Transforming the elements of a stream
Sorting the elements of a stream
Verifying conditions in the elements of a stream
Reactive programming with reactive streams
7
Concurrent Collections
Concurrent Collections
Introduction
Using non-blocking thread-safe deques
Using blocking thread-safe deques
Using blocking thread-safe queue ordered by priority
Using thread-safe lists with delayed elements
Using thread-safe navigable maps
Using thread-safe HashMaps
Using atomic variables
Using atomic arrays
Using the volatile keyword
Using variable handles
8
Customizing Concurrency Classes
Customizing Concurrency Classes
Introduction
Customizing the ThreadPoolExecutor class
Implementing a priority-based Executor class
Implementing the ThreadFactory interface to generate custom threads
Using our ThreadFactory in an Executor object
Customizing tasks running in a scheduled thread pool
Implementing the ThreadFactory interface to generate custom threads for the fork/join framework
Customizing tasks running in the fork/join framework
Implementing a custom Lock class
Implementing a transfer queue-based on priorities
Implementing your own atomic object
Implementing your own stream generator
Implementing your own asynchronous stream
9
Testing Concurrent Applications
Testing Concurrent Applications
Introduction
Monitoring a Lock interface
Monitoring a Phaser class
Monitoring an Executor framework
Monitoring a fork/join pool
Monitoring a stream
Writing effective log messages
Analyzing concurrent code with FindBugs
Configuring Eclipse for debugging concurrency code
Configuring NetBeans for debugging concurrency code
Testing concurrency code with MultithreadedTC
Monitoring with JConsole
10
Additional Information
Additional Information
Introduction
Processing results for Runnable objects in the Executor framework
Processing uncontrolled exceptions in a ForkJoinPool class
Using a blocking thread-safe queue for communicating with producers and consumers
Monitoring a Thread class
Monitoring a Semaphore class
Generating concurrent random numbers
11
Concurrent Programming Design
Concurrent Programming Design
Introduction
Using immutable objects when possible
Avoiding deadlocks by ordering locks
Using atomic variables instead of synchronization
Holding locks for as short time as possible
Delegating the management of threads to executors
Using concurrent data structures instead of programming yourself
Taking precautions using lazy initialization
Using the fork/join framework instead of executors
Avoiding the use of blocking operations inside a lock
Avoiding the use of deprecated methods
Using executors instead of thread groups
Using streams to process big data sets
Other tips and tricks

Avoiding deadlocks by ordering locks

When you need to acquire more than one lock in the methods of your application, you must be very careful with the order in which you get control of your locks. A bad choice can lead to a deadlock situation.

In this recipe, you will implement an example of a deadlock situation, then learn how to solve it.

How to do it...

Follow these steps to implement the example:

  1. Create a class named BadLocks with two methods, named operation1() and operation2():
        public class BadLocks { 
 
          private Lock lock1, lock2; 
 
          public BadLocks(Lock lock1, Lock lock2) { 
            this.lock1=lock1; 
            this.lock2=lock2; 
          } 
 
          public void operation1(){ 
            lock1.lock(); 
            lock2.lock(...
Previous Section
End of Section 4
Next Section