book

Mastering Concurrency Programming with Java 8

Name: Mastering Concurrency Programming with Java 8
Author: Javier Fernández González
ISBN: 9781785886126

by Javier Fernández González

February 2016

Intermediate to advanced

430 pages

9h 30m

English

Packt Publishing

Read now

Unlock full access

Mastering Concurrency Programming with Java 8
Table of Contents
Mastering Concurrency Programming with Java 8
Credits
About the Author
About the Reviewers
www.PacktPub.com
eBooks, discount offers, and moreWhy subscribe?
Preface
What this book covers
What you need for this book
Who this book is for

Conventions
Reader feedback
Customer support
Downloading the example codeErrataPiracyeBooks, discount offers, and moreQuestions
1. The First Step – Concurrency Design Principles
Basic concurrency conceptsConcurrency versus parallelismSynchronizationImmutable objectAtomic operations and variablesShared memory versus message passing
Possible problems in concurrent applications
Data raceDeadlockLivelockResource starvationPriority inversion
A methodology to design concurrent algorithms
The starting point – a sequential version of the algorithmStep 1 – analysisStep 2 – designStep 3 – implementationStep 4 – testingStep 5 – tuningConclusion
Java concurrency API
Basic concurrency classesSynchronization mechanismsExecutorsThe Fork/Join frameworkParallel streamsConcurrent data structures
Concurrency design patterns
SignalingRendezvousMutexMultiplexBarrierDouble-checked lockingRead-write lockThread poolThread local storage
The Java memory model
Tips and tricks to design concurrent algorithms
Identify the correct independent tasksImplement concurrency at the highest possible levelTake scalability into accountUse thread-safe APIsNever assume an execution orderPrefer local thread variables over static and shared when possibleFind the more easily parallelizable version of the algorithmUsing immutable objects when possibleAvoiding deadlocks by ordering the locksUsing atomic variables instead of synchronizationHolding locks for as short a time as possibleTaking precautions using lazy initializationAvoiding the use of blocking operations inside a critical section
Summary
2. Managing Lots of Threads – Executors
An introduction to executorsBasic characteristics of executorsBasic components of the executor framework
First example – the k-nearest neighbors algorithm
K-nearest neighbors – serial versionK-nearest neighbors – a fine-grained concurrent versionK-nearest neighbors – a coarse-grained concurrent versionComparing the solutions
The second example – concurrency in a client/server environment
Client/server – serial versionThe DAO partThe command partThe server partClient/server – parallel versionThe server partThe command partExtra components of the concurrent serverThe status commandThe cache systemThe log system
Comparing the two solutions
Other methods of interest
Summary
3. Getting the Maximum from Executors
Advanced characteristics of executorsCancellation of tasksScheduling the execution of tasksOverriding the executor methodsChanging some initialization parameters
The first example – an advanced server application
The ServerExecutor classThe statistics objectThe rejected task controllerThe executor tasksThe executorThe command classesThe ConcurrentCommand classConcrete commandsThe server partThe ConcurrentServer classThe RequestTask classThe client part
The second example – executing periodic tasks
The common partsThe basic readerThe advanced reader
Additional information about executors
Summary
4. Getting Data from the Tasks – The Callable and Future Interfaces
Introducing the Callable and Future interfacesThe Callable interfaceThe Future interface
First example – a best-matching algorithm for words
The common classesA best-matching algorithm – the serial versionThe BestMatchingSerialCalculation classThe BestMachingSerialMain classA best-matching algorithm – the first concurrent versionThe BestMatchingBasicTask classThe BestMatchingBasicConcurrentCalculation classA best-matching algorithm – the second concurrent versionThe word exists algorithm – a serial versionThe ExistSerialCalculation classThe ExistSerialMain classThe word exists algorithm – the concurrent versionThe ExistBasicTasks classThe ExistBasicConcurrentCalculation classThe ExistBasicConcurrentMain classComparing the solutionsBest-matching algorithmsExist algorithms
The second example – creating an inverted index for a collection of documents
Common classesThe Document classThe DocumentParser classThe serial versionThe first concurrent version – a task per documentThe IndexingTask classThe InvertedIndexTask classThe ConcurrentIndexing classThe second concurrent version – multiple documents per taskThe MultipleIndexingTask classThe MultipleInvertedIndexTask classThe MultipleConcurrentIndexing classComparing the solutionsOther methods of interest
Summary
5. Running Tasks Divided into Phases – The Phaser Class
An introduction to the Phaser classRegistration and deregistration of participantsSynchronizing phase changesOther functionalities
First example – a keyword extraction algorithm
Common classesThe Word classThe Keyword classThe Document classThe DocumentParser classThe serial versionThe concurrent versionThe KeywordExtractionTask classThe ConcurrentKeywordExtraction classComparing the two solutions
The second example – a genetic algorithm
Common classesThe Individual classThe GeneticOperators classThe serial versionThe SerialGeneticAlgorithm classThe SerialMain classThe concurrent versionThe SharedData classThe GeneticPhaser classThe ConcurrentGeneticTask classThe ConcurrentGeneticAlgorithm classThe ConcurrentMain classComparing the two solutionsThe Lau15 datasetThe Kn57 datasetConclusions
Summary
6. Optimizing Divide and Conquer Solutions – The Fork/Join Framework
An introduction to the Fork/Join frameworkBasic characteristics of the Fork/Join frameworkLimitations of the Fork/Join frameworkComponents of the Fork/Join framework
The first example – the k-means clustering algorithm
The common classesThe VocabularyLoader classThe Word, Document, and DocumentLoader classesThe DistanceMeasurer classThe DocumentCluster classThe serial versionThe SerialKMeans classThe concurrent versionTwo tasks for the Fork/Join framework – AssignmentTask and UpdateTaskThe ConcurrentKMeans classThe ConcurrentMain classComparing the solutions
The second example – a data filtering algorithm
Common partsThe serial versionThe SerialSearch classThe SerialMain classThe concurrent versionThe TaskManager classThe IndividualTask classThe ListTask classThe ConcurrentSearch classThe ConcurrentMain classComparing the two versions
The third example – the merge sort algorithm
Shared classesThe serial versionThe SerialMergeSort classThe SerialMetaData classThe concurrent versionThe MergeSortTask classThe ConcurrentMergeSort classThe ConcurrentMetaData classComparing the two versions
Other methods of the Fork/Join framework
Summary
7. Processing Massive Datasets with Parallel Streams – The Map and Reduce Model
An introduction to streamsBasic characteristics of streamsSections of a streamSources of a streamIntermediate operationsTerminal operationsMapReduce versus MapCollect
The first example – a numerical summarization application
The concurrent versionThe ConcurrentDataLoader classThe ConcurrentStatistics classJob information from subscribersAge data from subscribersMarital data from subscribersCampaign data from nonsubscribersMultiple data filterDuration data from nonsubscribersPeople aged between 25 and 50The ConcurrentMain classThe serial versionComparing the two versions
The second example – an information retrieval search tool
An introduction to the reduction operationThe first approach – full document queryThe basicMapper() methodThe Token classThe QueryResult classThe second approach – reduced document queryThe limitedMapper() methodThe third approach – generating an HTML file with the resultsThe ContentMapper classThe fourth approach – preloading the inverted indexThe ConcurrentFileLoader classThe fifth approach – using our own executorGetting data from the inverted index – the ConcurrentData classGetting the number of words in a fileGetting the average tfxidf value in a fileGetting the maximum and minimum tfxidf values in the indexThe ConcurrentMain classThe serial versionComparing the solutions
Summary
8. Processing Massive Datasets with Parallel Streams – The Map and Collect Model
Using streams to collect dataThe collect() method
The first example – searching data without an index
Basic classesThe Product classThe Review classThe ProductLoader classThe first approach – basic searchThe ConcurrentStringAccumulator classThe second approach – advanced searchThe ConcurrentObjectAccumulator classA serial implementation of the exampleComparing the implementations
The second example – a recommendation system
Common classesThe ProductReview classThe ProductRecommendation classThe recommendation system – the main classThe ConcurrentLoaderAccumulator classThe serial versionComparing the two versions
The third example – common contacts in a social network
Base classesThe Person classThe PersonPair classThe DataLoader classThe concurrent versionThe CommonPersonMapper classThe ConcurrentSocialNetwork classThe ConcurrentMain classThe serial versionComparing the two versions
Summary
9. Diving into Concurrent Data Structures and Synchronization Utilities
Concurrent data structuresBlocking and non-blocking data structuresInterfacesBlockingQueueBlockingDequeConcurrentMapTransferQueueClassesLinkedBlockingQueueConcurrentLinkedQueueLinkedBlockingDequeConcurrentLinkedDequeArrayBlockingQueueDelayQueueLinkedTransferQueuePriorityBlockingQueueConcurrentHashMapUsing the new featuresFirst example with ConcurrentHashMapThe forEach() methodThe search() methodThe reduce() methodThe compute() methodAnother example with ConcurrentHashMapAn example with the ConcurrentLinkedDeque classThe removeIf() methodThe spliterator() methodAtomic variables
Synchronization mechanisms
The CommonTask classThe Lock interfaceThe Semaphore classThe CountDownLatch classThe CyclicBarrier classThe CompletableFuture classUsing the CompletableFuture classAuxiliary tasksThe main() method
Summary
10. Integration of Fragments and Implementation of Alternatives
Big-block synchronization mechanisms
An example of a document clustering application
The four systems of k-means clusteringThe Reader systemThe Indexer systemThe Mapper systemThe Clustering systemThe main class of the document clustering applicationTesting our document clustering application
Implementation of alternatives with concurrent programming
The k-nearest neighbors' algorithmBuilding an inverted index of a collection of documentsA best-matching algorithm for wordsA genetic algorithmA keyword extraction algorithmA k-means clustering algorithmA filtering data algorithmSearching an inverted indexA numeric summarization algorithmA search algorithm without indexingA recommendation system using the Map and Collect model
Summary
11. Testing and Monitoring Concurrent Applications
Monitoring concurrency objectsMonitoring a threadMonitoring a lockMonitoring an executorMonitoring the Fork/Join frameworkMonitoring a PhaserMonitoring a stream
Monitoring concurrency applications
The Overview tabThe Monitor tabThe Threads tabThe Sampler tabThe Profiler tab
Testing concurrency applications
Testing concurrent applications with MultithreadedTCTesting concurrent applications with Java PathfinderInstalling Java PathfinderRunning Java Pathfinder
Summary
Index

Overview

Mastering Concurrency Programming with Java 8 introduces you to the foundational and advanced concepts of concurrent programming in Java. Through this book, you'll gain the skills to implement efficient, multi-threaded applications using Java 8's Concurrency API. The content is rich with hands-on examples and practical tips, ensuring you can apply your learning effectively.

What this Book will help me do

Understand the principles of concurrent application design and convert sequential algorithms into concurrent ones
Employ the Java 8 Executor framework for optimal task management without manually handling threads
Solve complex problems using the Fork/Join framework with the divide-and-conquer paradigm
Utilize parallel streams and Map/Reduce for processing large datasets efficiently
Implement data-race-free concurrent data structures and validate your applications through proper testing

Author(s)

Javier Fernández González is a seasoned software engineer and educator with extensive expertise in Java development and concurrent programming. With years of industry experience, Javier has contributed significantly to real-world software projects and has a passion for sharing his knowledge with the developer community. His practical and hands-on approach to teaching complex concepts makes his books indispensable resources for learners.

Who is it for?

If you're an experienced Java developer with an understanding of concurrency and want to deepen your expertise in writing efficient concurrent applications, this book is ideal for you. It's perfect for building robust systems that handle multi-threading and large datasets. Whether you're a professional aiming to refine your concurrent programming skills or an advanced learner seeking detailed insights into the Java 8 Concurrency API, this book will provide the clarity and practical knowledge you need.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Java 8 Fundamentals: Modern Java Development with Lambdas, Streams, and Introducing Java 9’s JShell and the Java Platform Module System (JPMS)

Paul Deitel

Publisher Resources

ISBN: 9781785886126

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills