Learning Path- Java- Delve Deep into Concurrency with Java 9

Learning Path: Java: Delve Deep into Concurrency with Java 9, available at $39.99, has an average rating of 3.94, with 87 lectures, 3 quizzes, based on 8 reviews, and has 145 subscribers.

You will learn about Learn to manage the basic components of the Java Concurrency API Use synchronization mechanisms to avoid data race conditions and other problems of concurrent applications Separate thread management from the rest of the application with the Executor framework Solve problems using a parallelized version of the divide-and-conquer paradigm with the Fork/Join framework Practice efficient techniques to test concurrent applications This course is ideal for individuals who are This Learning Path is targeted at developers who are familiar with Java programming and want to gain the skills of building highly-scalable, robust, and concurrent applications. It is particularly useful for This Learning Path is targeted at developers who are familiar with Java programming and want to gain the skills of building highly-scalable, robust, and concurrent applications.

Enroll now: Learning Path: Java: Delve Deep into Concurrency with Java 9

Summary

Title: Learning Path: Java: Delve Deep into Concurrency with Java 9

Price: $39.99

Average Rating: 3.94

Number of Lectures: 87

Number of Quizzes: 3

Number of Published Lectures: 87

Number of Published Quizzes: 3

Number of Curriculum Items: 90

Number of Published Curriculum Objects: 90

Original Price: $199.99

Quality Status: approved

Status: Live

What You Will Learn

Learn to manage the basic components of the Java Concurrency API

Use synchronization mechanisms to avoid data race conditions and other problems of concurrent applications

Separate thread management from the rest of the application with the Executor framework

Solve problems using a parallelized version of the divide-and-conquer paradigm with the Fork/Join framework

Practice efficient techniques to test concurrent applications

Who Should Attend

This Learning Path is targeted at developers who are familiar with Java programming and want to gain the skills of building highly-scalable, robust, and concurrent applications.

Target Audiences

This Learning Path is targeted at developers who are familiar with Java programming and want to gain the skills of building highly-scalable, robust, and concurrent applications.

Writing concurrent and parallel programming applications is a must-have skill for any Java programmer. Java 9 comes with a host of fantastic features, including significant performance improvements and new APIs. So, if you’re familiar with the basics of Java and want to understand concurrency and parallel programming techniques, then go for this Learning Path.

Packt’s Video Learning Paths are a series of individual video products put together in a logical and stepwise manner such that each video builds on the skills learned in the video before it.?

The highlights of this Learning Path are:

Practical examples on thread safety, high-performance classes, safe sharing, and much more

Understand Java 9 APIs and their impact on concurrency

Let’s take a look at your learning journey. You will know the elements of the Java concurrency API 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. Moving ahead, you’ll discover a whole range of recipes for almost everything, such as thread management, synchronization, executors, parallel and reactive streams, and much more.

By the end of this Learning Path, you will be able to deploy scalable and concurrent application

Meet Your Expert:

We have the best works of the following esteemed author to ensure that your learning journey is smooth:

Javier Fernández Gonzálezis a software architect with almost 15 years experience in Java technologies. He has worked as a teacher, researcher, programmer, analyst, and writer, and he now works as an architect in all types of projects related to Java, especially J2EE. As a teacher has over 1,000 hours of training in basic Java, J2EE, and the Struts framework. As a researcher, he has worked in the field of information retrieval, developing applications for processing large amounts of data in Java, and has participated as a co-author in several journal articles and conference presentations. Recently, he worked on developing J2EE web applications for various clients from different sectors (public administration, insurance, healthcare, transportation, and so on). He has also worked as a software architect. He is the author of the books, Java 7 Concurrency Cookbook and Mastering Concurrency Programming with Java 8 by Packt Publishing.

Course Curriculum

Chapter 1: Java 9 Concurrency – Basic Elements

Lecture 1: The Course Overview

Lecture 2: Creating, Running, and Setting the Characteristics of a Thread

Lecture 3: Interrupting a Thread

Lecture 4: Controlling the Interruption of a Thread

Lecture 5: Sleeping and Resuming a Thread

Lecture 6: Waiting for the Finalization of a Thread

Lecture 7: Creating and Running a Daemon Thread

Lecture 8: Processing Uncontrolled Exceptions in a Thread

Lecture 9: Using Thread Local Variables

Lecture 10: Grouping Threads and Processing Uncontrolled Exceptions in a Group of Threads

Lecture 11: Creating Threads Through a Factory

Lecture 12: Synchronizing a Method

Lecture 13: Using Conditions in Synchronized Code

Lecture 14: Synchronizing a Block of Code with a Lock

Lecture 15: Synchronizing Data Access with Read/Write Locks

Lecture 16: Using Multiple Conditions in a Lock

Lecture 17: Advanced Locking with the StampedLock Class

Lecture 18: Controlling Concurrent Access to One or More Copies of a Resource

Lecture 19: Waiting for Multiple Concurrent Events

Lecture 20: Synchronizing Tasks in a Common Point

Lecture 21: Running Concurrent-Phased Tasks

Lecture 22: Controlling Phase Change in Concurrent-Phased Tasks

Lecture 23: Exchanging Data Between Concurrent Tasks

Lecture 24: Completing and Linking Tasks Asynchronously

Chapter 2: Java 9 Concurrency – High-Level Elements

Lecture 1: The Course Overview

Lecture 2: Creating a Thread Executor and Controlling its Rejected Tasks

Lecture 3: Executing Tasks in an Executor that Returns a Result

Lecture 4: Running Multiple Tasks and Processing the First Result

Lecture 5: Running Multiple Tasks and Processing all the Results

Lecture 6: Running a Task in an Executor After a Delay

Lecture 7: Running a Task in an Executor Periodically

Lecture 8: Canceling a Task in an Executor

Lecture 9: Controlling a Task Finishing in an Executor

Lecture 10: Separating the Launching of Tasks and the Processing of their Results in an Exec

Lecture 11: Creating a Fork/Join Pool

Lecture 12: Joining the Results of the Tasks

Lecture 13: Running Tasks Asynchronously

Lecture 14: Throwing Exceptions in the Tasks

Lecture 15: Canceling a Task

Lecture 16: Creating Streams from Different Sources

Lecture 17: Reducing the Elements of a Stream

Lecture 18: Collecting the Elements of a Stream

Lecture 19: Applying an Action to Every Element of a Stream

Lecture 20: Filtering the Elements of a Stream

Lecture 21: Transforming the Elements of a Stream

Lecture 22: Sorting the Elements of a Stream

Lecture 23: Verifying Conditions in the Elements of a Stream

Lecture 24: Reactive Programming with Reactive Streams

Lecture 25: Using Non-Blocking Thread-Safe Deques

Lecture 26: Using Blocking Thread-Safe Deques

Lecture 27: Using Blocking Thread-Safe Queue Ordered by Priority

Lecture 28: Using Thread-Safe Lists with Delayed Elements

Lecture 29: Using Thread-Safe Navigable Maps

Lecture 30: Using Thread-Safe HashMaps

Lecture 31: Using Atomic Variables

Lecture 32: Using Atomic Arrays

Lecture 33: Using the Volatile Keyword

Lecture 34: Using Variable Handles

Chapter 3: Java 9 Concurrency- Advanced Elements

Lecture 1: The Course Overview

Lecture 2: Customizing the ThreadPoolExecutor Class

Lecture 3: Implementing a Priority –Based Executor Class

Lecture 4: Generate Custom Threads Using ThreadFactory Interface

Lecture 5: Using Our ThreadFactory in an Executor Object

Lecture 6: Customizing Tasks Running in a Scheduled Thread Pool

Lecture 7: Generating Custom Threads for the Fork/Join Framework

Lecture 8: Customizing Tasks Running in the Fork/Join Framework

Lecture 9: Implementing a Custom Lock Class

Lecture 10: Implementing a Transfer Queue-Based on Priorities

Lecture 11: Implementing Your Own Atomic Object

Lecture 12: Implementing Your Own Stream Generator

Lecture 13: Implementing Your Own Asynchronous Stream

Lecture 14: Monitoring a Lock Interface

Lecture 15: Monitoring a Phaser Class

Lecture 16: Monitoring an Executor Framework

Lecture 17: Monitoring a Fork/Join Pool

Lecture 18: Monitoring a Stream

Lecture 19: Writing Effective Log Messages

Lecture 20: Analyzing Concurrent Code with FindBugs

Lecture 21: Testing Concurrency Code with MultithreadedTC

Lecture 22: Monitoring with JConsole

Lecture 23: Using Atomic Variables Instead of Synchronization

Lecture 24: Holding Locks for as Short Time as Possible

Lecture 25: Delegating the Management of Threads to Executors

Lecture 26: Taking Precautions Using Lazy Initialization

Lecture 27: Using the Fork/Join Framework Instead of Executors

Lecture 28: Avoiding the Use of Blocking Operations Inside a Lock

Lecture 29: Using Streams to Process Big Data Sets

Instructors

Packt Publishing
Tech Knowledge in Motion

Rating Distribution

1 stars: 0 votes

2 stars: 1 votes

3 stars: 1 votes

4 stars: 5 votes

5 stars: 1 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!