Java Multithreading: Interview

Essentials by ScholarHat
Mastering concurrency is vital for building robust, high-performance
applications in modern distributed systems and backend services. This
presentation, brought to you
Java Multithreading: Interview Essentials by ScholarHat, dives deep into
the essential concepts and common interview questions around Java
multithreading. It's a crucial topic, appearing in over 80% of senior Java
developer interviews.
Why Multithreading in Java?

Increased Responsiveness
Keeps the User Interface (UI) active and smooth even when intensive background tasks are running, preventing freezes and improving user experien

Improved Throughput
Leverages multi-core CPUs to process a greater number of requests or tasks concurrently, significantly boosting overall system performance.

Resource Sharing
Threads within the same process share memory and resources, enabling efficient data exchange and communication between different
parts of an application.

Reduced Latency
Breaks down complex operations into smaller, parallelizable units, leading to faster completion times and more immediate responses.

Multithreading is fundamental in real-world applications such as web servers, database systems, gaming engines, and big data processing
frameworks, where concurrent execution is paramount.
Core Concepts: Process vs. Thread
Process

An independent execution unit that has its own isolated

memory space. Each Java Virtual Machine (JVM) instance runs
as a separate process.

Thread

A light-weight unit of execution that runs within a process.

Threads share the process's memory space, making
communication efficient.

Concurrency

Refers to multiple tasks appearing to run simultaneously, often

achieved through time-slicing on a single CPU core. It's about
dealing with many things at once.

The JVM itself utilizes several threads, including the main application
Parallelism
thread, the garbage collector thread for memory management, and
Involves multiple tasks actually running simultaneously on the JIT compiler threads for optimizing bytecode execution.
multiple CPU cores or processors. It's about doing many things Understanding these distinctions is crucial for effective multithreaded
at once. programming.
Creating Threads: `Thread` vs. `Runnable`
In Java, there are two primary ways to create and manage threads, each with its own advantages and typical use cases.

Runnable Interface (Preferred) Thread Class (Less Preferred)

This method involves implementing the Runnable interface, This approach involves extending the Thread class and
which only requires implementing the public void run() overriding its run() method. While functional, it's less
method. It is generally preferred because it separates the task preferred due to Java's single inheritance limitation.
logic from thread management.

class MyThread extends Thread { public void

Thread t = new Thread(new run() { ... }}MyThread t = new
MyRunnable());t.start(); MyThread();t.start();

Using Runnable also supports scenarios where a class needs to

implement multiple interfaces, as Java does not support
multiple inheritance for classes. It's crucial to understand the difference between start() and
run(). Calling start() creates a new thread and executes its
run() method in that new thread, whereas calling run()
directly simply executes the code in the current thread,
without creating a new one.
Synchronization & Locks
When multiple threads access shared resources, issues like race conditions, data inconsistency, and deadlocks can arise. Java provides mechanisms to control thread access
to critical sections.

The Problem synchronized Keyword Lock Interface (`ReentrantLock`)

Uncontrolled concurrent access to shared data can This built-in keyword ensures that only one thread Located in java.util.concurrent.locks, the Lock
lead to unpredictable results, where the final state can execute a synchronized method or block for a interface, commonly implemented by
depends on the arbitrary timing of thread execution. given object or class at a time. It can be applied to ReentrantLock, offers more flexible and explicit
This can manifest as race conditions, data methods (acquiring the object's intrinsic lock) or to control over locking mechanisms.
corruption, or deadlocks where threads perpetually blocks of code (specifying the lock object). Lock lock = new
wait for each other. ReentrantLock();lock.lock();try { ... }
synchronized void myMethod() finally { lock.unlock(); }
{ ... }synchronized (this) { ... }
It provides methods like lock(), unlock(), and
tryLock(), along with options for fairness. This is
essential for sophisticated concurrency control
beyond the capabilities of the synchronized
keyword.
Concurrency Utilities: ExecutorService & Thread
Pools
Manually creating and managing individual threads can be error-prone and resource-intensive. Java's
java.util.concurrent package provides powerful utilities to simplify this.

Challenge
Directly managing threads, including creation, lifecycle, and destruction, can lead to bugs, resource
exhaustion, and complex code.

ExecutorService
A high-level API that separates task submission from thread execution. It manages a pool of worker threads
and submits tasks to them.

ExecutorService executor = Executors.newFixedThreadPool(10);executor.submit(new

MyRunnable());executor.shutdown();

Thread Pools
A collection of pre-instantiated threads that are reused to execute multiple tasks. This significantly reduces
the overhead associated with creating and destroying threads. Common types include:

• FixedThreadPool: A pool with a fixed number of threads.

• CachedThreadPool: Creates new threads as needed, but reuses idle ones.
• ScheduledThreadPool: For delayed or periodic task execution.

Benefits
Using ExecutorService and thread pools leads to improved application performance, better utilization of
system resources, and much easier management of concurrent tasks.
Common Multithreading Problems
Race Condition
Occurs when multiple threads try to access and modify shared data concurrently,
leading to an unpredictable or incorrect final outcome because the sequence of
operations is not guaranteed. For instance, two threads incrementing an
unsynchronized counter might yield a wrong total.

Deadlock
A situation where two or more threads are permanently blocked, each waiting for a
resource that is held by another thread in the same cycle. The four conditions for a
deadlock are Mutual Exclusion, Hold and Wait, No Preemption, and Circular Wait.
Prevention often involves consistent lock ordering or using timeouts on locks.

Livelock
Similar to deadlock, but threads are not blocked; instead, they continuously change
their state in response to each other without making any actual progress. Imagine two
people politely trying to avoid each other in a narrow corridor, endlessly stepping aside.

Starvation
Happens when a thread repeatedly loses the race for a shared resource or CPU time to
other threads. This can occur due to unfair scheduling or specific thread priorities.
Solutions include using fair locks (e.g., ReentrantLock(true)) or ensuring appropriate
thread priorities.
volatile Keyword and Atomic Operations
volatile Keyword Atomic Operations (`java.util.concurrent.atomic`)

The volatile keyword ensures that changes made to a variable by one thread are The java.util.concurrent.atomic package provides classes like AtomicInteger,
immediately visible to all other threads. When a variable is declared volatile: AtomicLong, and AtomicBoolean that support atomic operations on single variables.

• Writes to the variable are always written to main memory, not just to a CPU cache. These classes provide thread-safe operations without the need for explicit locking,
• Reads from the variable are always read from main memory, not from a stale using a technique called Compare-And-Swap (CAS). For example,

cached value. atomicInt.incrementAndGet() performs a truly atomic increment operation,

guaranteeing correct results even with multiple threads.
This prevents CPU caching issues that can lead to inconsistent data views across
threads. However, volatile does not guarantee atomicity for operations that
involve multiple steps (e.g., i++ is not atomic, as it involves reading, incrementing,
and writing).
Advanced Concurrency Concepts
Callable & Future
Unlike Runnable, a Callable task can return a result and throw checked exceptions. The result of a Callable is
obtained via a Future object, which represents the result of an asynchronous computation.

Future future = executor.submit(new MyCallable());Integer result = future.get();

The get() method is a blocking call that waits for the computation to complete.

CountDownLatch
A synchronization aid that allows one or more threads to wait until a set of operations being performed in other
threads completes. You initialize a CountDownLatch with a count. Threads call countDown() to decrement the
count, and a thread calls await() to wait until the count reaches zero.

CountDownLatch latch = new CountDownLatch(N);// ... threads perform work and call
latch.countDown();latch.await();

Semaphore
A Semaphore controls access to a common resource by maintaining a set of permits. Threads acquire a permit to
access the resource and release it when done. This is useful for limiting the number of threads that can access a
critical section or resource (e.g., limiting concurrent database connections).

Semaphore semaphore = new Semaphore(permits);semaphore.acquire();// access

resourcesemaphore.release();
Conclusion: Best Practices & Continuous Learning

Prioritize Runnable
1 For clear separation of concerns between task logic and thread management.

Use ExecutorService
2 For efficient thread management, always preferring thread pools.

Synchronize Access
3 Protect shared mutable state using synchronized or Lock.

Prefer java.util.concurrent
4 For modern, robust, and scalable concurrency tools.

Understand Problems
5 Be able to identify and resolve race conditions, deadlocks, and livelocks.

Further Resources

6 Explore ScholarHat's advanced Java concurrency courses and "Java

Concurrency in Practice" by Brian Goetz for deeper insights.