Parallel and Reactive Streams | Java 9 Concurrency Cookbook, Second Edition

Book Overview & Buying
Table Of Contents
Feedback & Rating

Java 9 Concurrency Cookbook, Second Edition

By : Javier Fernández González

4 (1)

Buy this Book

Java 9 Concurrency Cookbook, Second Edition

4 (1)

By: Javier Fernández González

Buy this Book

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.

Title Page

Credits

About the Author

About the Reviewer

www.PacktPub.com

Customer Feedback

Dedication

Preface

Free Chapter

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

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

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

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

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

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

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

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

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

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

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

Customer Reviews

4 (1)

5 star

4 star

100%

3 star

2 star

1 star

Java 9 Concurrency Cookbook, Second Edition

By : Javier Fernández González

Java 9 Concurrency Cookbook, Second Edition

By: Javier Fernández González

Overview of this book

Reactive programming with reactive streams

Limited Time Offer

$10p/m for 3 months

Java 9 Concurrency Cookbook, Second Edition

By : Javier Fernández González

Java 9 Concurrency Cookbook, Second Edition

By: Javier Fernández González

Overview of this book

Reactive programming with reactive streams

Limited Time Offer

$10p/m for 3 months

Confirmation

Buy this book with your credits?

Submit Your Feedback

Create a Note

Delete Bookmark

Delete Note

Edit Note