MULTITHREADING &

MULTITASKING IN JAVA
1. Introduction to Multithreading and Multitasking
1.1 What is Multithreading?
Multithreading is the concept in programming that allows a single program to perform multiple tasks
concurrently. In simple terms, it divides a program into smaller, independent units called threads, which
can execute simultaneously. This is especially useful in applications that need to perform multiple tasks,
such as downloading files while processing data.

1.2 What is Multitasking?

Multitasking is the ability of an operating system (OS) to run multiple tasks simultaneously. These tasks
can be independent programs or threads. The system allocates resources such as CPU time to different
tasks, allowing them to run seemingly at the same time.

1.3 Difference between Multithreading and Multitasking

While both involve performing multiple tasks at the same time, the main difference is that
multithreading deals with running multiple threads within a single process, while multitasking involves
running multiple processes or programs, which may or may not contain multiple threads.

2. Understanding Multithreading in Java

2.1 Definition of Multithreading in Java
Multithreading in Java enables the concurrent execution of two or more threads. A thread is the smallest
unit of a CPU’s execution. Java provides built-in support for multithreading through the Thread class
and the Runnable interface.

2.2 Significance of Multithreading

Multithreading is crucial for improving the performance of Java applications. By executing multiple
tasks simultaneously, it helps in:

• Efficient CPU Utilization: Multiple threads can run on multi-core processors, utilizing CPU
resources more effectively.

• Increased Responsiveness: For applications like GUIs, multithreading ensures that the
interface remains responsive while performing time-consuming operations in the background.

• Improved Resource Sharing: Threads can share resources within a process, making the
program more efficient.

1
2.3 Threads in Java
A thread in Java represents a single sequence of execution. Each thread has its own execution path, and
multiple threads can run concurrently within a single Java program. You can create a thread in two
ways:

• Extending the Thread class: By subclassing Thread and overriding the run() method.

• Implementing the Runnable interface: By implementing the Runnable interface and passing
it to a Thread object.

2.4 Advantages of Multithreading

• Better Utilization of Resources: Threads allow concurrent execution of tasks, which leads to
better resource utilization.

• Improved Application Performance: Multithreading allows performing different tasks

simultaneously, leading to faster execution of complex programs.

• Increased Responsiveness: By allowing non-blocking execution, multithreading ensures that

applications remain responsive even during intensive operations.

2.5 How Java Manages Multithreading

Java handles multithreading through the Java Virtual Machine (JVM). The JVM manages threads and
schedules their execution on the available CPU cores. This is done using the thread scheduling
mechanisms that prioritize threads based on factors like priority and availability of CPU resources.

3. Understanding Multitasking
3.1 What is Multitasking?
Multitasking refers to the capability of a system to perform multiple tasks or processes simultaneously.
In a multitasking environment, the operating system allocates CPU time to each task, giving the illusion
that they are running at the same time.

3.2 Types of Multitasking

1. Process-Based Multitasking: This involves running multiple processes, where each process
has its own memory space. Examples include running multiple applications at once.

2. Thread-Based Multitasking: This involves multiple threads within the same process, where
threads share the same memory space but can execute independently.

3.3 Cooperative vs. Pre-emptive Multitasking

• Cooperative Multitasking: The running task voluntarily gives up control of the CPU, allowing
another task to run.

• Preemptive Multitasking: The OS forcibly takes control from a running task and allocates
CPU time to other tasks. This is more common in modern OS environments.

2
3.4 The Role of the Operating System
The operating system plays a key role in multitasking by managing the allocation of resources such as
memory, CPU time, and input/output devices. It ensures that tasks are performed efficiently, without
conflicts.

3.5 Benefits of Multitasking

Multitasking enhances system performance by:

• Reducing idle times in the CPU.

• Allowing multiple programs to run simultaneously, improving overall productivity.

• Efficiently utilizing system resources.

4. Thread Life Cycle in Java

4.1 Overview of Thread Life Cycle
A thread in Java goes through several states during its life. The thread life cycle is managed by the JVM
and can transition between various states:

1. New: The thread is created but not yet started.

2. Runnable: The thread is ready to execute, and the JVM can schedule it.

3. Blocked: The thread is blocked due to resource unavailability.

4. Waiting: The thread is waiting for a specific event or condition.

5. Timed Waiting: The thread is waiting for a specified time.

6. Terminated: The thread has completed its execution.

4.2 Transition Between States

• A thread starts in the New state.

• Once start() is called, it transitions to the Runnable state.

• If it requires resources, it may enter the Blocked or Waiting state.

• The thread may stay in the Timed Waiting state for a specified duration.

• Finally, it moves to the Terminated state when its task is completed.

5. Thread Synchronization in Java

5.1 Introduction to Synchronization
Synchronization is crucial when multiple threads access shared resources. Without synchronization,
threads may conflict, causing data inconsistency or race conditions. Java provides mechanisms to
synchronize methods or blocks of code.

3
5.2 Methods of Synchronization
• Synchronized Methods: By using the synchronized keyword, you can ensure that only one
thread at a time can execute a particular method.

• Synchronized Blocks: You can synchronize specific sections of code, providing more granular
control over resource access.

5.3 Race Conditions and Deadlocks

• Race Condition: Occurs when two or more threads attempt to modify shared data
simultaneously.

• Deadlock: A situation where two or more threads are blocked indefinitely, waiting for each
other to release resources.

5.4 Synchronization Best Practices

• Use synchronization sparingly, only when necessary.

• Avoid deadlocks by designing the program carefully.

• Minimize the scope of synchronized blocks for efficiency.

6. Example Program: Demonstrating Multithreading

in Java
class BankAccount

private int balance;

public BankAccount(int balance)

this.balance = balance;

public synchronized void deposit(int amount)

balance += amount;

System.out.println(Thread.currentThread().getName() + " deposited Rs." +

amount);

System.out.println("Balance: Rs." + balance);

notify();

public synchronized void withdraw(int amount)

while (balance < amount)

4
 try

System.out.println(Thread.currentThread().getName() + " waiting for

balance.");

wait();

catch (InterruptedException e)

e.printStackTrace();

balance -= amount;

System.out.println(Thread.currentThread().getName() + " withdrew Rs." +

amount);

System.out.println("Balance: Rs." + balance);

public synchronized int getBalance()

return balance;

class Customer extends Thread

private BankAccount account;

private String operation;

private int amount;

public Customer(BankAccount account, String operation, int amount)

this.account = account;

this.operation = operation;

this.amount = amount;

@OVERRIDE

public void run()

if ("deposit".equalsIgnoreCase(operation))

account.deposit(amount);
5
 }

else if ("withdraw".equalsIgnoreCase(operation))

account.withdraw(amount);

public class BankApplication

public static void main(String[] args)

BankAccount account = new BankAccount(1000);

Customer customer1 = new Customer(account, "withdraw", 1500);

Customer customer2 = new Customer(account, "deposit", 1000);

Customer customer3 = new Customer(account, "withdraw", 500);

customer1.start();

customer2.start();

customer3.start();

try

customer1.join();

customer2.join();

customer3.join();

catch (InterruptedException e)

e.printStackTrace();

System.out.println("Final balance: Rs." + account.getBalance());

Sample Output:
Customer-0 waiting for balance.

Customer-1 deposited Rs.1000

Balance: Rs.2000

Customer-2 withdrew Rs.500

6
Balance: Rs.1500

Customer-0 withdrew Rs.1500

Balance: Rs.0

Final balance: Rs.0

7. Key Points and Tips for Multithreading and

Multitasking in Java
7.1 Key Differences Between Multithreading and Multitasking
• Multithreading occurs within a single process, while Multitasking involves multiple
processes.

• Multithreading is more efficient for sharing resources within the same process.

7.2 Best Practices for Multithreading

• Avoid Deadlocks: Ensure proper resource management to prevent deadlocks.

• Minimize Synchronization: Synchronize only critical sections of code to avoid performance

bottlenecks.

• Use Thread Pools: For managing a large number of threads, use ExecutorService to manage
thread pools efficiently.

7.3 Common Mistakes to Avoid

• Not synchronizing shared resources properly.

• Ignoring exception handling in threads.

• Not joining threads before exiting the program, leading to incomplete execution.