Book Overview & Buying
Table Of Contents
Feedback & Rating

Mastering Concurrency Programming with Java 9, Second Edition - 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

Second example - concurrency in a client/server environment

The client/server model is a software architecture where applications are split into two parts: the server part that provides resources (data, operations, printer, storage, and so on) and the client part that uses the resources provided by the server. Traditionally, this architecture was used in the enterprise world but, with the boom in the internet, is still an actual topic. You can see a web application as a client/server application where the server part is the backend part of the application that is executed on a web server and the web navigator executes the client part of the application. SOA (short for Service-Oriented Architecture) is another example of a client/server architecture where the web services exposed are the server part and the different clients that consume them are the client part.

In a client/server...