Book Overview & Buying
Table Of Contents
Feedback & Rating

Mastering Concurrency Programming with Java 9, Second Edition

By : Javier Fernández González

3.8 (4)

Buy this Book

Mastering Concurrency Programming with Java 9, Second Edition

3.8 (4)

By: Javier Fernández González

Buy this Book

Overview of this book

Concurrency programming allows several large tasks to be divided into smaller sub-tasks, which are further processed as individual tasks that run in parallel. Java 9 includes a comprehensive API with lots of ready-to-use components for easily implementing powerful concurrency applications, but with high flexibility so you can adapt these components to your needs. The book starts with a full description of the design principles of concurrent applications and explains how to parallelize a sequential algorithm. You will then be introduced to Threads and Runnables, which are an integral part of Java 9's concurrency API. You will see how to use all the components of the Java concurrency API, from the basics to the most advanced techniques, and will implement them in powerful real-world concurrency applications. The book ends with a detailed description of the tools and techniques you can use to test a concurrent Java application, along with a brief insight into other concurrency mechanisms in JVM.

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Free Chapter

The First Step - Concurrency Design Principles

Basic concurrency concepts

Possible problems in concurrent applications

A methodology to design concurrent algorithms

Java Concurrency API

Concurrency design patterns

Tips and tricks for designing concurrent algorithms

Summary

Working with Basic Elements - Threads and Runnables

Threads in Java

First example: matrix multiplication

Second example - file search

Summary

Managing Lots of Threads - Executors

An introduction to executors

First example - the k-nearest neighbors algorithm

Second example - concurrency in a client/server environment

Summary

Getting the Most from Executors

Advanced characteristics of executors

First example - an advanced server application

Second example - executing periodic tasks

Additional information about executors

Summary

Getting Data from Tasks - The Callable and Future Interfaces

Introducing the Callable and Future interfaces

First example - a best-matching algorithm for words

The second example - creating an inverted index for a collection of documents

Summary

Running Tasks Divided into Phases - The Phaser Class

An introduction to the Phaser class

First example - a keyword extraction algorithm

The second example - a genetic algorithm

Summary

Optimizing Divide and Conquer Solutions - The Fork/Join Framework

An introduction to the fork/join framework

The first example - the k-means clustering algorithm

The second example - a data filtering algorithm

The third example - the merge sort algorithm

Other methods of the fork/join framework

Summary

Processing Massive Datasets with Parallel Streams - The Map and Reduce Model

An introduction to streams

The first example - a numerical summarization application

The second example - an information retrieval search tool

Summary

Processing Massive Datasets with Parallel Streams - The Map and Collect Model

Using streams to collect data

The first example - searching data without an index

The second example - a recommendation system

The third example - common contacts in a social network

Summary

Asynchronous Stream Processing - Reactive Streams

Introduction to reactive streams in Java

The first example - a centralized system for event notification

The second example - a news system

Summary

Diving into Concurrent Data Structures and Synchronization Utilities

Concurrent data structures

Synchronization mechanisms

Summary

Testing and Monitoring Concurrent Applications

Monitoring concurrency objects

Monitoring concurrency applications

Testing concurrency applications

Summary

Concurrency in JVM - Clojure and Groovy with the Gpars Library and Scala

Concurrency in Clojure

Concurrency in Groovy with the GPars library

Software transactional memory

Concurrency in Scala

Summary

Customer Reviews

3.8 (4)

5 star

25%

4 star

25%

3 star

50%

2 star

1 star

An introduction to executors

As we explain in Chapter 2, Working with Basic Elements - Threads and Runnables, the basic mechanism to implement a concurrent application in Java is:

A class that implements the Runnable interface: This is the code you want to implement in a concurrent way
An instance of the Thread class: This is the thread that is going to execute the code in a concurrent way

With this approach, you're responsible for creating and manning the thread objects and implementing the mechanisms of synchronization between the threads. However, it can create some problems, especially with those applications with a lot of concurrent tasks. If you create too many threads, you can degrade the performance of your application or even hang the entire system.

Java version 5 included the Executor framework to solve these problems and provide an efficient solution that is...