Mastering Concurrency Programming with Java 9

Cover
Copyright
Credits
About the Author
About the Reviewer
www.PacktPub.com
Customer Feedback
Table of Contents
Preface
Chapter 1: The First Step - Concurrency Design Principles
	Basic concurrency concepts
		Concurrency versus parallelism
		Synchronization
		Immutable object
		Atomic operations and variables
		Shared memory versus message passing
	Possible problems in concurrent applications
		Data race
		Deadlock
		Livelock
		Resource starvation
		Priority inversion
	A methodology to design concurrent algorithms
		The starting point - a sequential version of the algorithm
		Step 1 - analysis
		Step 2 - design
		Step 3 - implementation
		Step 4 - testing
		Step 5 - tuning
		Conclusion
	Java Concurrency API
		Basic concurrency classes
		Synchronization mechanisms
		Executors
		The fork/join framework
		Parallel streams
		Concurrent data structures
	Concurrency design patterns
		Signaling
		Rendezvous
		Mutex
		Multiplex
		Barrier
		Double-checked locking
		Read-write lock
		Thread pool
		Thread local storage
	Tips and tricks for designing concurrent algorithms
		Identifying the correct independent tasks
		Implementing concurrency at the highest possible level
		Taking scalability into account
		Using thread-safe APIs
		Never assume an execution order
		Preferring local thread variables over static and shared when possible
		Finding the easier parallelizable version of the algorithm
		Using immutable objects when possible
		Avoiding deadlocks by ordering the locks
		Using atomic variables instead of synchronization
		Holding locks for as short a time as possible
		Taking precautions using lazy initialization
		Avoiding the use of blocking operations inside a critical section
	Summary
Chapter 2: Working with Basic Elements - Threads and Runnables
	Threads in Java
		Threads in Java - characteristics and states
		The Thread class and the Runnable interface
	First example: matrix multiplication
		Common classes
		Serial version
		Parallel versions
			First concurrent version - a thread per element
			Second concurrent version - a thread per row
			Third concurrent version - the number of threads is determined by the processors
		Comparing the solutions
	Second example - file search
		Common classes
		Serial version
		Concurrent version
		Comparing the solutions
	Summary
Chapter 3: Managing Lots of Threads - Executors
	An introduction to executors
		Basic characteristics of executors
		Basic components of the Executor framework
	First example - the k-nearest neighbors algorithm
		k-nearest neighbors - serial version
		K-nearest neighbors - a fine-grained concurrent version
		k-nearest neighbors - a coarse-grained concurrent version
		Comparing the solutions
	Second example - concurrency in a client/server environment
		Client/server - serial version
			The DAO part
			The command part
			The server part
		Client/version - parallel version
			The server part
			The command part
		Extra components of the concurrent server
			The status command
			The cache system
			The log system
			Comparing the two solutions
		Other methods of interest
	Summary
Chapter 4: Getting the Most from Executors
	Advanced characteristics of executors
		Cancellation of tasks
		Scheduling the execution of tasks
		Overriding the executor methods
		Changing some initialization parameters
	First example - an advanced server application
		The ServerExecutor class
			The statistics object
			The rejected task controller
			The executor tasks
			The executor
		The command classes
			The ConcurrentCommand class
			The concrete commands
		The server part
			The ConcurrentServer class
			The RequestTask class
		The client part
	Second example - executing periodic tasks
		The common parts
		The basic reader
		The advanced reader
	Additional information about executors
	Summary
Chapter 5: Getting Data from Tasks - The Callable and Future Interfaces
	Introducing the Callable and Future interfaces
		The Callable interface
		The Future interface
	First example - a best-matching algorithm for words
		The common classes
		A best-matching algorithm - the serial version
			The BestMatchingSerialCalculation class
			The BestMachingSerialMain class
		A best-matching algorithm - the first concurrent version
			The BestMatchingBasicTask class
			The BestMatchingBasicConcurrentCalculation class
		A best-matching algorithm - the second concurrent version
		Word exists algorithm - a serial version
			The ExistSerialCalculation class
			The ExistSerialMain class
		Word exists algorithm - the concurrent version
			The ExistBasicTasks class
			The ExistBasicConcurrentCalculation class
			The ExistBasicConcurrentMain class
		Comparing the solutions
			Best-matching algorithms
			Exist algorithms
	The second example - creating an inverted index for a collection of documents
		Common classes
			The Document class
			The DocumentParser class
		The serial version
		The first concurrent version - a task per document
			The IndexingTask class
			The InvertedIndexTask class
			The ConcurrentIndexing class
		The second concurrent version - multiple documents per task
			The MultipleIndexingTask class
			The MultipleInvertedIndexTask class
			The MultipleConcurrentIndexing class
		Comparing the solutions
		Other methods of interest
	Summary
Chapter 6: Running Tasks Divided into Phases - The Phaser Class
	An introduction to the Phaser class
		Registration and deregistration of participants
		Synchronizing phase change
		Other functionalities
	First example - a keyword extraction algorithm
		Common classes
			The Word class
			The Keyword class
			The Document class
			The DocumentParser class
		The serial version
		The concurrent version
			The KeywordExtractionTask class
			The ConcurrentKeywordExtraction class
		Comparing the two solutions
	The second example - a genetic algorithm
		Common classes
			The Individual class
			The GeneticOperators class
		The serial version
			The SerialGeneticAlgorithm class
			The SerialMain class
		The concurrent version
			The SharedData class
			The GeneticPhaser class
			The ConcurrentGeneticTask class
			The ConcurrentGeneticAlgorithm class
			The ConcurrentMain class
		Comparing the two solutions
			Lau15 dataset
			Kn57 dataset
			Conclusions
	Summary
Chapter 7: Optimizing Divide and Conquer Solutions - The Fork/Join Framework
	An introduction to the fork/join framework
		Basic characteristics of the fork/join framework
		Limitations of the fork/join framework
		Components of the fork/join framework
	The first example - the k-means clustering algorithm
		The common classes
			The VocabularyLoader class
			The word, document, and DocumentLoader classes
			The DistanceMeasurer class
			The DocumentCluster class
		The serial version
			The SerialKMeans class
			The SerialMain class
		The concurrent version
			Two tasks for the fork/join framework - AssignmentTask and UpdateTask
			The ConcurrentKMeans class
			The ConcurrentMain class
		Comparing the solutions
	The second example - a data filtering algorithm
		Common features
		The serial version
			The SerialSearch class
			The SerialMain class
		The concurrent version
			The TaskManager class
			The IndividualTask class
			The ListTask class
			The ConcurrentSearch class
			The ConcurrentMain class
		Comparing the two versions
	The third example - the merge sort algorithm
		Shared classes
		The serial version
			The SerialMergeSort class
			The SerialMetaData class
		The concurrent version
			The MergeSortTask class
			The ConcurrentMergeSort class
			The ConcurrentMetaData class
		Comparing the two versions
	Other methods of the fork/join framework
	Summary
Chapter 8: Processing Massive Datasets with Parallel Streams - The Map and Reduce Model
	An introduction to streams
		Basic characteristics of streams
		Sections of a stream
			Sources of a stream
			Intermediate operations
			Terminal operations
		MapReduce versus MapCollect
	The first example - a numerical summarization application
		The concurrent version
			The ConcurrentDataLoader class
			The ConcurrentStatistics class
				Customers from the United Kingdom
				Quantity from the United Kingdom
			Countries for product
				Quantity for product
				Multiple data filter
				Highest invoice amounts
				Products with a unit price between 1 and 10
			The ConcurrentMain class
		The serial version
		Comparing the two versions
	The second example - an information retrieval search tool
		An introduction to the reduction operation
		The first approach - full document query
			The basicMapper() method
			The Token class
			The QueryResult class
		The second approach - reduced document query
			The limitedMapper() method
		The third approach - generating an HTML file with the results
			The ContentMapper class
		The fourth approach - preloading the inverted index
			The ConcurrentFileLoader class
		The fifth approach - using our own executor
		Getting data from the inverted index - the ConcurrentData class
		Getting the number of words in a file
		Getting the average tfxidf value in a file
		Getting the maximum and minimum tfxidf values in the index
		The ConcurrentMain class
		The serial version
		Comparing the solutions
	Summary
Chapter 9: Processing Massive Datasets with Parallel Streams - The Map and Collect Model
	Using streams to collect data
		The collect() method
	The first example - searching data without an index
		Basic classes
			The Product class
			The Review class
			The ProductLoader class
		The first approach - basic search
			The ConcurrentStringAccumulator class
		The second approach - advanced search
			The ConcurrentObjectAccumulator class
		A serial implementation of the example
		Comparing the implementations
	The second example - a recommendation system
		Common classes
			The ProductReview class
			The ProductRecommendation class
		Recommendation system - the main class
		The ConcurrentLoaderAccumulator class
		The serial version
		Comparing the two versions
	The third example - common contacts in a social network
		Base classes
			The Person class
			The PersonPair class
			The DataLoader class
		The concurrent version
			The CommonPersonMapper class
			The ConcurrentSocialNetwork class
			The ConcurrentMain class
		The serial version
			Comparing the two versions
	Summary
Chapter 10: Asynchronous Stream Processing - Reactive Streams
	Introduction to reactive streams in Java
		The Flow.Publisher interface
		The Flow.Subscriber interface
		The Flow.Subscription interface
		The SubmissionPublisher class
	The first example - a centralized system for event notification
		The Event class
		The Producer class
		The Consumer class
		The Main class
	The second example - a news system
		The News class
		The publisher classes
		The Consumer class
		The Main class
	Summary
Chapter 11: Diving into Concurrent Data Structures and Synchronization Utilities
	Concurrent data structures
		Blocking and non-blocking data structures
		Concurrent data structures
			Interfaces
				BlockingQueue
				BlockingDeque
				ConcurrentMap
				TransferQueue
			Classes
				LinkedBlockingQueue
				ConcurrentLinkedQueue
				LinkedBlockingDeque
				ConcurrentLinkedDeque
				ArrayBlockingQueue
				DelayQueue
				LinkedTransferQueue
				PriorityBlockingQueue
				ConcurrentHashMap
		Using the new features
			First example with ConcurrentHashMap
				The forEach() method
				The search() method
				The reduce() method
				The compute() method
			Another example with ConcurrentHashMap
			An example with the ConcurrentLinkedDeque class
				The removeIf() method
				The spliterator() method
		Atomic variables
		Variable handles
	Synchronization mechanisms
		The CommonTask class
		The Lock interface
		The Semaphore class
		The CountDownLatch class
		The CyclicBarrier class
		The CompletableFuture class
			Using the CompletableFuture class
				Auxiliary tasks
				The main() method
	Summary
Chapter 12: Testing and Monitoring Concurrent Applications
	Monitoring concurrency objects
		Monitoring a thread
		Monitoring a lock
		Monitoring an executor
		Monitoring the fork/join framework
		Monitoring a Phaser
		Monitoring the Stream API
	Monitoring concurrency applications
		The Overview tab
		The Memory tab
		The Threads tab
		The Classes tab
		The VM summary tab
		The MBeans tab
		The About tab
	Testing concurrency applications
		Testing concurrent applications with MultithreadedTC
		Testing concurrent applications with Java Pathfinder
			Installing Java Pathfinder
			Running Java Pathfinder
	Summary
Concurrency in JVM - Clojure and Groovy with the Gpars Library and Scala
	Concurrency in Clojure
		Using Java elements
		Reference types
			Atoms
			Agents
		Refs
		Delays
		Futures
		Promises
	Concurrency in Groovy with the GPars library
	Software transactional memory
		Using Java elements
		Data parallelism
		The fork/join processing
		Actors
		Agent
		Dataflow
	Concurrency in Scala
		Future objects in Scala
		Promises
	Summary
Index