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.

Preface

What this book covers

What you need for this book

Who this book is for

Reader feedback

Customer support

Free Chapter

Thread Management

Thread Management

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

Basic Thread Synchronization

Basic Thread Synchronization

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

Thread Synchronization Utilities

Thread Synchronization Utilities

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

Thread Executors

Thread Executors

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

Fork/Join Framework

Fork/Join Framework

Creating a fork/join pool

Joining the results of the tasks

Running tasks asynchronously

Throwing exceptions in the tasks

Canceling a task

Parallel and Reactive Streams

Parallel and Reactive Streams

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

Concurrent Collections

Concurrent Collections

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

Customizing Concurrency Classes

Customizing Concurrency Classes

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

Testing Concurrent Applications

Testing Concurrent Applications

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

Additional Information

Additional Information

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

Concurrent Programming Design

Concurrent Programming Design

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

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Holding locks for as short time as possible

Locks, just like other synchronization mechanisms, allow the definition of a critical section that only one thread can execute at a time. You must be very careful to define the critical section. It must only include those instructions that really need mutual exclusion. This is especially true if the critical section includes long operations. If the critical section includes lengthy operations that do not use shared resources, application performance will be worse than it could be.

In this recipe, you 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.

Getting ready

The example of this...