Concurrency, Multithreading and Parallel Computing in Java

Install Java Development Kit 23 on Windows by downloading from Oracle and running the installer. Update environment variables with the JDK bin path and verify with Java C and version.

Explore why Java multithreading prevents application freezing by offloading time-consuming tasks to separate threads, explain the difference between processes and threads, and introduce synchronization for concurrent programming.

Explore how a single cpu uses the time-slicing algorithm to switch between multiple threads. When multiple cores are available, the operating system can run threads in parallel, enabling true parallelization.

learn how multithreading makes apps more responsive by running time-consuming tasks in parallel threads, using time slicing, efficient CPU utilization, and executing work on multiple cores.

Identify the disadvantages of multithreading, including data contention and complex synchronization, plus the difficulty of designing and testing threaded apps.

Trace the four thread lifecycle phases—from new to terminated—covering active, vulnerable, runnable, running, and blocked states, with transitions via start, join, sleep, and wait.

Explore sequential processing in java, illustrate line-by-line execution of methods and runners, and introduce multi-threading to run tasks concurrently using multiple threads.

Learn to start Java threads via the runnable interface, override the run method, and run two runners concurrently using time slicing and optional lambda expressions.

Explore starting threads in Java using runnable, anonymous inner classes, lambdas, or by extending the thread class; learn start, run, and sleep, plus handling interruptions and simple time-slicing behavior.

Understand how join waits for threads to finish in a multi-threaded Java program, ensuring the main thread coordinates download images and process images using join and handling InterruptedException.

Learn to list active threads in the JVM using get all stack traces, print thread names and states, and identify main, runner threads, and garbage collector daemon threads.

Explore the three types of threads in Java—user, worker, and daemon—how to create them with runnable or by extending Thread, and why the JVM exits when only daemon threads remain.

Explore how thread priority and the Java thread scheduler interact with the operating system, revealing time slicing, range 1–10, default 5, and non-deterministic behavior across platforms.

Protect a shared counter with synchronization to ensure thread safety when multiple threads increment it, preventing data inconsistency and non-deterministic results.

Explain how the synchronized keyword uses an intrinsic lock to ensure a single thread enters a method at a time, making other threads wait and potentially slowing the program.

Explores object-level locking on instantiated objects versus class-level locking on the class. Shows that static synchronized methods share a class lock, so threads wait; avoid class-level locking when possible.

Explain how wait and notify coordinate threads synchronized on the same intrinsic lock, illustrate with a producer–consumer example, and discuss non-determinism and fairness concerns.

Implement the producer-consumer pattern from scratch using a shared buffer and linked list, with synchronized produce and consume methods, wait and notify for inter-thread communication and a capacity limit.

Explore why Joshua Bloch advises using a while loop with wait() in producer-consumer patterns, guarding against spurious wakeups and non-deterministic scheduling and guiding toward reentrant locks.

Explore how locks and re-entrant locks improve on synchronized blocks by enabling trylock, interruptible waits, and condition-based coordination, with fair and unfair options and starvation considerations.

Learn how re-entrant locks synchronize a shared counter, compare with synchronized blocks, and ensure the lock is released in a finally block.

Explore the producer consumer pattern using a re-entrant lock and condition to coordinate two threads with await and signal, featuring producer and consumer methods and explicit lock management.

Explore deadlocks and livelocks in Java threads, and prevent them with reentrant locks, tryLock, same-order lock acquisition, and randomized retries.

Demonstrates a deadlock with two locks and competing threads, showing how cyclic dependency arises when lock order differs, and how aligning lock acquisition in the same order eliminates deadlocks.

Explore a livelock scenario with two threads and two reentrant locks, using trylock to show progress stalls and how to avoid cyclic dependencies to resolve the issue.

Use the volatile keyword to make shared updates visible across threads. It provides lightweight synchronization by preventing CPU caches and optimizations from hiding changes in main memory.

Learn why Java's thread stop is deprecated and implement safe thread termination by using a volatile boolean flag checked in the run method to stop execution.

Discover atomic variables in java.util.concurrent, including atomic integers, longs, and booleans, and learn to perform thread-safe increments without synchronization using get and increment.

Explore semaphores as a fundamental synchronization tool, distinguishing binary and counting types, and see how they manage resource counts, enable producer–consumer solutions, and prepare for mutual exclusion and Java implementation.

Mutexes enforce mutual exclusion, allowing one thread at a time in a critical section, ensuring thread safety. Semaphores enable signaling and resource counting, with ownership differences compared to mutexes.

Explore how semaphores regulate access to shared resources with a permit counter. See acquire and release in action, with fairness for three permits in Java multithreading.

Avoid manual threads; use thread pools, including fixed, cached, single, and scheduled, via the executor service to reuse workers, queue tasks, and support futures, callables, and graceful shutdown.

Explore how to implement a single thread executor in Java by creating runnable tasks with IDs, simulating work, and executing five tasks sequentially using Executors.newSingleThreadExecutor.

Create a fixed thread pool with a defined number of threads to run tasks. Observe how the executor service manages execution and shutdown, removing the need to manually handle threads.

Leverage a scheduled thread pool to run a stock market updater every two seconds by implementing runnable and scheduling execution with a single thread to fetch stock market data.

Learn how to shut down and terminate an executor service in Java using a fixed thread pool, with an orderly shutdown and await termination.

Demonstrate returning values from threads using callable and future objects in Java. Create a processor implementing callable, submit tasks to a two-thread fixed pool, and retrieve results with futures.

Explore the java collections framework, its interfaces and implementations, and learn how concurrent collections and the Collections.synchronize method address thread safety.

Explore how synchronized collections prevent concurrent access issues by using Collections.synchronizedList, Collections.synchronizedMap, and Collections.synchronizedSet. Compare intrinsic locking with concurrent collections to understand why concurrent solutions offer better efficiency and scalability.

Explore countdown latches as a synchronization aid that lets threads await a set of operations to complete, decoupling task coordination from thread tracking with executor services.

Explore blocking queues in java's concurrency package, focusing on array blocking queue, its fixed size, single lock, and producer-consumer use with take and put operations.

Use linked blocking queue to allow concurrent puts and takes with separate locks. It supports bounded and unbounded configurations and helps decide when to use array blocking queues.

Explore delay queue, an unbounded blocking queue for delayed objects, which blocks on take until delays expire and reports a size including expired and unexpired items.

Explore the priority blocking queue in Java, a thread-safe, unbounded blocking queue backed by a heap, ordering items by priority with a single reentrant lock and logarithmic operations.

Explore how concurrent maps extend hash maps with segment-level locking to allow parallel reads and writes. Learn how CAS, bucket locks, and tree-bin locks after Java eight ensure thread safety.

Show how the Exchanger enables two threads to exchange objects via the exchange method, blocking until the partner arrives. Demonstrate with a counter increment/decrement exchange between two threads.

Copy on write arrays implement the list interface and let readers access data without locking, while writers copy the underlying array to make updates atomic, which makes writes expensive.

Explore dining philosophers problem, formulated by Dijkstra, where five philosophers contend for five chopsticks, learn how deadlocks occur in a multi-threaded setting, and study left-first then right pickup and release.

Design and implement the dining philosophers problem by creating an application, a constants class with a private constructor, a chopstick state enum, and philosopher and chopstick classes.

initialize the dining philosophers simulation with five philosophers and chopsticks, assign them to a fixed thread pool, use modulo for wraparound, and shut down the executor after running.

Demonstrates the dining philosophers problem with a 5-second simulation of philosophers picking up left and right chopsticks, eating, and releasing locks, using trialogue to avoid thread starvation and deadlocks.