COMPREHENSIVE DOCUMENTATION ON

MULTITHREADING IN JAVA (18 PAGES)

PAGE 1: INTRODUCTION TO MULTITHREADING

Multithreading is a fundamental concept in modern software development,

allowing applications to perform multiple tasks concurrently. In Java,
multithreading is well-supported, enabling developers to build highly responsive
and efficient applications. This documentation will guide you through the
intricacies of multithreading in Java, from basic concepts to advanced techniques.

What is a Thread?

A thread is the smallest unit of execution within a process. A process can have
multiple threads, each executing a different task independently. This allows for
parallelism, where multiple tasks can run seemingly simultaneously.

Benefits of Multithreading:

• Responsiveness: Keeps the application interactive, especially during long-

running operations.
• Resource Sharing: Threads within the same process share memory and
resources, leading to efficiency.
• Performance: Can significantly improve performance on multi-core
processors by utilizing parallel execution.
• Simplified Modeling: Can make it easier to model real-world problems that
involve concurrent activities.

PAGE 2: THREADS VS. PROCESSES

Understanding the difference between threads and processes is crucial. A process

is an independent program executing, with its own memory space, system
resources, and execution context. Threads, on the other hand, are lightweight units
within a process that share the process's resources.

Key Differences:

• Memory Space: Processes have separate memory spaces; threads share the
memory space of their parent process.
 • Communication: Inter-process communication (IPC) is more complex and
resource-intensive than inter-thread communication.
• Creation Cost: Creating a new process is more expensive in terms of time and
resources than creating a new thread.
• Fault Isolation: If one thread crashes, it can bring down the entire process. If
one process crashes, it typically does not affect other processes.

Java applications are typically single processes, but they can utilize multiple threads
for concurrent execution.

PAGE 3: CREATING THREADS IN JAVA - THE THREAD CLASS

Java provides the java.lang.Thread class to create and manage threads. There
are two primary ways to create a thread using this class:

1. Extending the Thread class: Create a class that extends Thread and
overrides its run() method.
2. Implementing the Runnable interface: Create a class that implements
Runnable and provides an implementation for its run() method.

Extending the Thread class:

class MyThread extends Thread {

public void run() {
System.out.println("Thread is running by extending Thread class.");
}
}

public class Main {

public static void main(String[] args) {
MyThread thread1 = new MyThread();
thread1.start(); // Starts the thread, which then calls run()
}
}

The start() method is crucial; it allocates system resources for the new thread
and then calls the run() method.
PAGE 4: CREATING THREADS IN JAVA - THE RUNNABLE INTERFACE

Implementing the Runnable interface is generally the preferred approach for

creating threads in Java. This is because it promotes better code organization and
allows your class to extend other classes if needed (Java does not support multiple
inheritance of classes).

Implementing the Runnable interface:

class MyRunnable implements Runnable {

public void run() {
System.out.println("Thread is running by implementing Runnable inte
}
}

public class Main {

public static void main(String[] args) {
MyRunnable runnableTask = new MyRunnable();
Thread thread1 = new Thread(runnableTask); // Create a Thread objec
thread1.start(); // Starts the thread
}
}

This approach separates the task (Runnable) from the thread execution
mechanism (Thread).

PAGE 5: THREAD LIFECYCLE AND STATES

A thread in Java goes through several states during its existence. Understanding
these states is vital for managing thread execution and preventing common issues.

Thread States:

• New (Born): When a thread object is created but its start() method has not
yet been called.
• Runnable: The thread is ready to run and is waiting for its turn to be executed
by the CPU. The start() method transitions a thread to this state.
• Running: The thread is currently executing its run() method.
• Blocked/Waiting: The thread is temporarily unable to execute. This can
happen due to I/O operations, waiting for another thread to release a lock, or
explicit calls to wait(), sleep(), or join().
 • Terminated (Dead): The thread has finished its execution (its run() method
has completed) or has been abruptly stopped.

The Java Virtual Machine (JVM) manages the transitions between these states.

PAGE 6: THREAD PRIORITIES AND SCHEDULING

Java allows you to assign priorities to threads, influencing the order in which the
JVM's thread scheduler selects them for execution. Thread priorities are integers
ranging from 1 (minimum priority) to 10 (maximum priority).

Key Methods:

• setPriority(int newPriority): Sets the priority of a thread.

• getPriority(): Returns the priority of a thread.

Default Priorities:

• The main thread has a priority of 5.

• New threads created by extending Thread inherit the priority of the parent
thread.

Thread Scheduling:

Thread scheduling is the process by which the JVM decides which runnable thread
gets to run on the CPU. It's typically preemptive, meaning a higher-priority thread
can interrupt a lower-priority thread.

Caution: Over-reliance on priorities can lead to complex scheduling issues and is

generally discouraged in favor of synchronization mechanisms.

PAGE 7: THE `SLEEP()` METHOD

The Thread.sleep(long millis) method is used to pause the current thread

for a specified number of milliseconds. When a thread calls sleep(), it enters the
Timed Waiting state and releases the CPU, allowing other threads to run.

Use Cases:

• Introducing delays in execution for observation or testing.

• Simulating real-world delays.
• Giving other threads a chance to run.
Important Notes:

• sleep() does not release any locks the thread might hold.
• It can be interrupted by another thread calling the interrupt() method on
it, which will throw an InterruptedException.

public void run() {

try {
for (int i = 0; i < 5; i++) {
System.out.println("Thread executing: " + i);
Thread.sleep(1000); // Pause for 1 second
}
} catch (InterruptedException e) {
System.out.println("Thread interrupted.");
}
}

PAGE 8: THE `JOIN()` METHOD

The Thread.join() method allows one thread to wait for another thread to
complete its execution. When a thread calls join() on another thread, it enters the
Waiting state until the target thread terminates.

Use Cases:

• Ensuring that a sequence of operations is performed in a specific order.

• Waiting for background tasks to finish before proceeding.

Syntax:

• thread.join(): Waits indefinitely for the thread to die.

• thread.join(long millis): Waits for a maximum of millis milliseconds.

public class JoinExample {

public static void main(String[] args) {
Thread workerThread = new Thread(() -> {
try {
System.out.println("Worker thread started.");
Thread.sleep(2000); // Simulate work
System.out.println("Worker thread finished.");
} catch (InterruptedException e) {
e.printStackTrace();
}
 });

workerThread.start();

try {
System.out.println("Main thread waiting for worker thread to fi
workerThread.join(); // Main thread waits here
System.out.println("Main thread proceeding after worker thread
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

PAGE 9: THE `YIELD()` METHOD

The Thread.yield() method is a static method that suggests the current thread
voluntarily give up its current execution time, allowing other threads of the same
priority to run. If no other threads of the same priority are waiting, the current
thread may continue its execution.

Behavior:

• It's a hint to the scheduler, not a command. The JVM is free to ignore it.
• It can be useful in scenarios where a thread performs a long computation and
wants to allow other threads to run periodically without blocking entirely.

Use with Caution:

The behavior of yield() is platform-dependent and can be unpredictable. It's

generally less useful than other synchronization mechanisms and should be used
sparingly.

public void run() {

for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + " is performi
Thread.yield(); // Suggest yielding CPU time
}
}
PAGE 10: SYNCHRONIZATION - THE `SYNCHRONIZED` KEYWORD

When multiple threads access shared resources (like variables or objects), race
conditions can occur, leading to unpredictable results. Synchronization is used to
prevent this by ensuring that only one thread can access a shared resource at a
time.

The synchronized keyword in Java can be applied in two ways:

1. Synchronized Methods: When a method is declared as synchronized, a

thread must acquire an intrinsic lock (monitor) on the object before it can
execute the method. If another thread already holds the lock, the current
thread will block until the lock is released.
2. Synchronized Blocks: You can synchronize a specific block of code using the
synchronized keyword with an object reference. This allows for finer-grained
control over which code sections are protected.

// Synchronized Method
public synchronized void display(String msg) {
System.out.print(msg);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(" ended.");
}

// Synchronized Block
public void displayBlock(String msg) {
synchronized (this) { // Synchronize on the current object
System.out.print(msg);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(" ended.");
}
}
PAGE 11: SYNCHRONIZATION - `WAIT()`, `NOTIFY()`, `NOTIFYALL()`

The methods wait(), notify(), and notifyAll() are essential for inter-thread
communication and coordination, particularly within synchronized blocks or
methods. They are defined in the Object class.

Key Methods:

• wait(): Causes the current thread to pause execution and release the lock it
holds on the object. The thread enters the Waiting state until another thread
invokes notify() or notifyAll() on the same object, or until a specified
timeout occurs.
• notify(): Wakes up a single thread that is waiting on this object's monitor. If
multiple threads are waiting, one is chosen arbitrarily.
• notifyAll(): Wakes up all threads that are waiting on this object's monitor.

Requirement: These methods can only be called from within a synchronized

context (method or block) on the object whose monitor the thread holds.

Producer-Consumer Example: A common pattern where these methods are used

is the producer-consumer problem, where one thread produces data and another
consumes it.

PAGE 12: DEADLOCKS

A deadlock is a situation where two or more threads are blocked forever, each
waiting for the other to release a resource that it needs. This is a critical issue in
multithreaded programming that can halt application progress.

Conditions for Deadlock (Coffman conditions):

1. Mutual Exclusion: At least one resource must be held in a non-sharable

mode.
2. Hold and Wait: A thread must be holding at least one resource and waiting to
acquire additional resources held by other threads.
3. No Preemption: Resources cannot be forcibly taken away from a thread; they
must be voluntarily released.
4. Circular Wait: A set of threads {T0, T1, ..., Tn} must exist such that T0 is
waiting for a resource held by T1, T1 is waiting for a resource held by T2, ...,
and Tn is waiting for a resource held by T0.

Example Scenario:
Thread A locks Resource 1 and needs Resource 2.
Thread B locks Resource 2 and needs Resource 1.

Prevention: Carefully design lock acquisition order, use timeouts for lock
acquisition, or use higher-level concurrency utilities.

PAGE 13: THREAD POOLS AND EXECUTORS

Managing threads manually can be inefficient. Thread pools provide a way to reuse
threads, reducing the overhead of creating and destroying them. The
java.util.concurrent package offers powerful tools for managing thread
pools.

Key Interface: ExecutorService

ExecutorService is an interface that represents an asynchronous execution

mechanism. It allows you to submit tasks for execution without explicitly managing
thread lifecycles.

Common Implementations:

• Executors.newFixedThreadPool(int nThreads): Creates a thread pool

with a fixed number of threads.
• Executors.newCachedThreadPool(): Creates a thread pool that creates
new threads as needed but reuses existing threads when available.
• Executors.newSingleThreadExecutor(): Creates an executor that uses a
single worker thread.

Submitting Tasks:

• execute(Runnable command): Submits a Runnable task for execution.

• submit(Callable<T> task): Submits a Callable task (which can return a
result) and returns a Future.

PAGE 14: THE `CALLABLE` AND `FUTURE` INTERFACES

While `Runnable` tasks execute without returning a result, `Callable` tasks can
return a result and throw checked exceptions.

Callable<V> Interface:

Contains a single method: V call() throws Exception;

Future<?> Interface:

Represents the result of an asynchronous computation. It provides methods to

check if the computation is complete, to wait for its completion, and to retrieve the
result of the computation.

Key Methods of Future:

• V get(): Waits if necessary for the computation to complete, and then

retrieves its result.
• V get(long timeout, TimeUnit unit): Waits at most the given time for
the computation to complete, and then retrieves its result.
• boolean isDone(): Returns true if the computation is done.
• boolean cancel(boolean mayInterruptIfRunning): Attempts to cancel
the execution of the task.

import java.util.concurrent.*;

// ... inside a method ...

ExecutorService executor = Executors.newSingleThreadExecutor();
Callable task = () -> {
// Simulate a long-running task
TimeUnit.SECONDS.sleep(2);
return 123;
};

Future future = executor.submit(task);

System.out.println("Task submitted.");
// ... do other work ...
try {
Integer result = future.get(); // Waits for the result
System.out.println("Result: " + result);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
executor.shutdown();

PAGE 15: LOCKS - `REENTRANTLOCK`

The `java.util.concurrent.locks` package provides more flexible and powerful

locking mechanisms than the built-in `synchronized` keyword. `ReentrantLock` is a
common implementation.
Advantages over `synchronized`:

• Timed Lock Acquisition: Can try to acquire a lock for a specified duration
using tryLock(long time, TimeUnit unit).
• Interruptible Lock Acquisition: A thread trying to acquire the lock can be
interrupted using lockInterruptibly().
• Fairness: Can be configured for fairness, where the longest-waiting thread
acquires the lock first (though this can impact performance).
• Condition Variables: Can use `newCondition()` to create multiple condition
variables associated with the lock, offering more sophisticated waiting and
signaling than `wait()/notify()`.

Basic Usage:

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {

private final ReentrantLock lock = new ReentrantLock();
private int count = 0;

public void increment() {

lock.lock(); // Acquire the lock
try {
count++;
System.out.println(Thread.currentThread().getName() + " increme
} finally {
lock.unlock(); // Release the lock in a finally block
}
}
// ... other methods ...
}

It's crucial to always release the lock in a finally block.

PAGE 16: SEMAPHORES

A Semaphore is a synchronization aid that maintains a set of permits. Threads

acquire permits to access a resource, and release them when done. If no permits
are available, a thread trying to acquire one will block.
Use Cases:

• Controlling access to a limited number of resources: e.g., database

connections, network sockets.
• Signaling: Can be used for basic signaling between threads.

Key Methods:

• acquire(): Acquires a permit, blocking if none are available.

• tryAcquire(): Tries to acquire a permit without blocking.
• release(): Releases a permit, returning it to the semaphore.

import java.util.concurrent.Semaphore;

public class SemaphoreExample {

// Allow only 2 threads to access the resource at a time
private static final int MAX_AVAILABLE = 2;
private final Semaphore available = new Semaphore(MAX_AVAILABLE, true);

public void doWork(int taskNumber) {

try {
System.out.println("Task " + taskNumber + " trying to acquire p
available.acquire(); // Acquire a permit
System.out.println("Task " + taskNumber + " acquired permit. Wo
Thread.sleep(2000); // Simulate work
System.out.println("Task " + taskNumber + " finished work.");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
available.release(); // Release the permit
System.out.println("Task " + taskNumber + " released permit.");
}
}
}

PAGE 17: ATOMIC VARIABLES

Atomic variables, found in java.util.concurrent.atomic (e.g.,

AtomicInteger, AtomicLong, AtomicBoolean), provide lock-free, thread-safe
operations on single variables. They use low-level atomic hardware instructions,
offering better performance than traditional locks for simple operations.
Advantages:

• Performance: Often faster than synchronized blocks for single-variable

updates.
• Simplicity: Easy to use for common atomic operations.
• Lock-Free: Avoids issues like deadlocks associated with locks.

Common Operations:

• getAndIncrement(): Atomically increments the value and returns the old

value.
• incrementAndGet(): Atomically increments the value and returns the new
value.
• compareAndSet(expectedValue, newValue): Atomically sets the value to
newValue if the current value == expectedValue. This is the fundamental
building block.

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicIntegerExample {

private AtomicInteger counter = new AtomicInteger(0);

public void incrementCounter() {

counter.incrementAndGet(); // Atomically increments
System.out.println(Thread.currentThread().getName() + " - Counter:
}

public int getCounterValue() {

return counter.get();
}
}

PAGE 18: BEST PRACTICES AND CONCLUSION

Writing effective multithreaded Java applications requires careful consideration of

several factors.

Best Practices:

• Prefer Runnable over extending Thread: For better design flexibility.

• Use ExecutorService: For efficient thread management.
• Prefer Callable and Future: When tasks need to return results.
 • Use Atomic Variables: For simple, high-performance atomic operations.
• Be Cautious with Locks: Use ReentrantLock for more control, but always
ensure locks are released.
• Avoid Excessive Synchronization: Synchronize only the critical sections
necessary to prevent performance bottlenecks.
• Minimize Shared Mutable State: Design your code so that shared data is
immutable or accessed carefully.
• Handle Exceptions: Always handle InterruptedException and other
potential exceptions in your threads.
• Test Thoroughly: Multithreading bugs can be subtle and hard to reproduce.
Test under various conditions.

Conclusion:

Multithreading in Java is a powerful tool for building concurrent, responsive, and

performant applications. By understanding the core concepts, lifecycle,
synchronization mechanisms, and concurrency utilities, developers can effectively
leverage multithreading to enhance their applications. Remember to prioritize
clarity, safety, and performance in your multithreaded designs.