Class Central is learner-supported. When you buy through links on our site, we may earn an affiliate commission.

Concurrency in Java - Practical Multithreading - 2026

Packt via Coursera

Go to class Write review

Details

Go to class

Provider

Coursera
Pricing

Paid Course
Languages

English
Certificate

Certificate Available
Effort

12 weeks, 1 hour a week
Sessions

Self-Paced
Level

Intermediate
Subtitles

English

Found in

Overview

Google, IBM & Meta Certificates – 40% Off

One plan covers every Professional Certificate on Coursera.

Unlock All Certificates

This course features Coursera Coach! A smarter way to learn with interactive, real-time conversations that help you test your knowledge, challenge assumptions, and deepen your understanding as you progress through the course. Learn how to build faster, safer, and more responsive Java applications by mastering practical multithreading concepts. You will understand how threads work, why concurrency matters, and how to prevent common issues such as race conditions, thread interference, and inconsistent shared data. The course begins with Java multithreading fundamentals, then moves into creating, starting, managing, and interrupting threads. You will explore synchronization, thread communication with wait, notify, and notifyAll, and techniques for coordinating work between concurrent tasks. You will then progress into modern Java concurrency tools, including the Executor framework, thread pools, Fork/Join framework, atomic variables, thread-local variables, and the Lock framework. The course also covers thread groups and uncaught exception handling for more reliable applications. This beginner-to-intermediate course is ideal for Java developers, software engineers, and programming students with basic Java knowledge. By the end of the course, you will be able to create and manage threads, synchronize shared resources, use Java concurrency utilities, design thread-safe code, and handle exceptions in multithreaded applications.

Syllabus

Introduction to Multithreading in Java

In this module, we will introduce the core concepts of multithreading in Java. You will understand why concurrency is crucial for building efficient applications. The module sets the foundation for creating and managing multiple threads effectively.

Thread creation and management

In this module, we will explore the techniques for creating and managing threads in Java. You will learn the essential steps to spawn threads and control their lifecycle. This knowledge is critical for designing robust concurrent applications.

Synchronization

In this module, we will focus on synchronization in Java. You will learn how to ensure thread safety when multiple threads access shared resources. The module provides practical strategies to avoid race conditions and maintain data consistency.

Thread Interruption

In this module, we will examine thread interruption techniques in Java. You will learn how to stop threads safely and handle interruptions without causing inconsistencies. These practices are essential for maintaining robust multithreaded applications.

Thread Communication

In this module, we will explore techniques for inter-thread communication. You will learn how threads can synchronize actions using Java’s communication methods. This ensures threads interact efficiently and safely within concurrent programs.

The Executor Framework

In this module, we will dive into the Executor framework in Java. You will learn how to simplify task execution and thread management. The module highlights modern concurrency tools that improve scalability and code maintainability.

The Fork/Join Framework

In this module, we will introduce the Fork/Join framework in Java. You will learn how to split tasks into smaller units and process them in parallel. This approach enhances performance for computationally intensive algorithms.

Thread Pools

In this module, we will discuss thread pools in Java. You will learn how to manage a pool of threads and improve efficiency through reuse. This ensures optimal resource management in concurrent applications.

Thread Safety and Atomic Variables

In this module, we will explore thread safety concepts and atomic variables in Java. You will learn how to avoid data corruption when multiple threads modify shared resources. These practices are key to building reliable concurrent applications.

Thread Local Variables

In this module, we will examine thread-local variables in Java. You will learn how to store data unique to each thread, avoiding conflicts. This technique enhances performance and simplifies data management in concurrent applications.

Lock Framework

In this module, we will cover the Java Lock framework. You will learn about different lock implementations and how to manage thread synchronization effectively. The module provides techniques for fine-grained concurrency control.

Thread Group and Uncaught Exception Handler

In this module, we will explore thread groups and uncaught exception handling in Java. You will learn how to organize threads and catch exceptions safely. This ensures robust and maintainable multithreaded applications.