Scribd
Upload
17 views9 pages

Java Thread vs Runnable Comparison

The document contains an assignment with multiple questions related to Java multithreading concepts, including the differences between Thread and Runnable, thread creation, synchronization to avoid race conditions, advantages of HashMap, producer-consumer problem using wait and notify, and deadlocks. Each question is followed by a detailed solution with code examples and explanations. The document emphasizes the importance of thread management, synchronization, and data structures in Java programming.

Uploaded by

abhitoshgurung112
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
17 views9 pages

Java Thread vs Runnable Comparison

The document contains an assignment with multiple questions related to Java multithreading concepts, including the differences between Thread and Runnable, thread creation, synchronization to avoid race conditions, advantages of HashMap, producer-consumer problem using wait and notify, and deadlocks. Each question is followed by a detailed solution with code examples and explanations. The document emphasizes the importance of thread management, synchronization, and data structures in Java programming.

Uploaded by

abhitoshgurung112
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd

Assignment 5

Note: Attempt any two questions from the following [5 Marks Each]

Q1: Explain the difference between the Thread class and the Runnable interface in Java.
Provide examples of situations where you might choose one approach over the other.

SOLUTION : In Java, `Thread` and `Runnable` are two ways to create and manage
threads. Here's the difference between them:

# Thread Class:
- A `Thread` is a class that represents a separate ow of execution in a program.
- To create a new thread using the `Thread` class, you need to extend the `Thread` class
and override the `run()` method.
- The `Thread` class provides methods to control the thread's execution, such as `start()`,
`join()`, and `interrupt()`.

# Runnable Interface:
- A `Runnable` is an interface that represents a task that can be executed by a thread.
- To create a new thread using the `Runnable` interface, you need to implement the
`Runnable` interface and provide an implementation for the `run()` method.
- A `Runnable` object can be passed to a `Thread` object, which will execute the `run()`
method.

# Key Differences:
1. *Inheritance*: When you extend the `Thread` class, you can't extend any other class.
When you implement the `Runnable` interface, you can still extend other classes.
2. *Flexibility*: The `Runnable` interface provides more exibility, as you can pass a
`Runnable` object to different types of executors or threads.
3. *Reusability*: A `Runnable` object can be reused in different threads, whereas a
`Thread` object is tightly coupled to its execution.

# Choosing Between Thread and Runnable:


1. *Use Thread*: When you need to control the thread's execution directly, such as when
you need to use thread-speci c methods like `join()` or `interrupt()`.
2. *Use Runnable*: When you want to decouple the task from the thread execution, or
when you need to pass the task to different types of executors or threads.

# Examples:
*Thread Example:*
```
public class MyThread extends Thread {
@Override
public void run() {
[Link]("Hello from thread!");
}

public static void main(String[] args) {


MyThread thread = new MyThread();
[Link]();
}
}
```
fi
fl
fl
Assignment 5

*Runnable Example:*
```
public class MyRunnable implements Runnable {
@Override
public void run() {
[Link]("Hello from runnable!");
}

public static void main(String[] args) {


MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
[Link]();
}
}
```

Q2: Write a Java program that demonstrates the creation of a thread by extending the
Thread class. Include a simple task for the thread to execute.

SOLUTION: Here's a Java program that demonstrates the creation of a thread by


extending the `Thread` class:

# Creating a Thread by Extending Thread Class:


```
// De ne a class that extends Thread
class MyThread extends Thread {
private String threadName;

public MyThread(String threadName) {


[Link] = threadName;
}

@Override
public void run() {
// Task to be executed by the thread
[Link](threadName + " is starting.");
for (int i = 1; i <= 5; i++) {
[Link](threadName + " is running iteration " + i);
try {
[Link](1000); // Sleep for 1 second
} catch (InterruptedException e) {
[Link](threadName + " was interrupted.");
}
}
[Link](threadName + " has nished.");
}
}

public class Main {


fi
fi
Assignment 5
public static void main(String[] args) {
// Create two threads
MyThread thread1 = new MyThread("Thread-1");
MyThread thread2 = new MyThread("Thread-2");

// Start the threads


[Link]();
[Link]();
}
}
```

# Explanation:
1. *De ne a class that extends Thread*: We de ne a class `MyThread` that extends the
`Thread` class.
2. *Override the run() method*: We override the `run()` method to de ne the task that the
thread will execute.
3. *Create and start threads*: In the `main()` method, we create two instances of
`MyThread` and start them using the `start()` method.

# Output:
The output will show both threads running concurrently, with each thread printing its name
and iteration number. The exact output may vary due to the concurrent nature of thread
execution.

# Key Points:
1. *Thread creation*: Threads are created by extending the `Thread` class and overriding
the `run()` method.
2. *Thread execution*: Threads are executed by calling the `start()` method, which calls
the `run()` method internally.
3. *Concurrency*: Multiple threads can run concurrently, improving responsiveness and
system utilization.

Note: Attempt any two questions from the following [10 Marks Each]

Q4: Implement a Java program that shows the use of synchroniSation to avoid race
conditions. Provide a brief explanation of how synchronisation is achieved in your program

SOLUTION : Here's a Java program that demonstrates the use of synchronization to avoid
race conditions:

# Synchronized Program:
```
class Counter {
private int count = 0;

// Synchronized method to increment count


public synchronized void increment() {
count++;
fi
fi
fi
Assignment 5
}

// Synchronized method to get count


public synchronized int getCount() {
return count;
}
}

class CounterThread extends Thread {


private Counter counter;

public CounterThread(Counter counter) {


[Link] = counter;
}

@Override
public void run() {
for (int i = 0; i < 100000; i++) {
[Link]();
}
}
}

public class Main {


public static void main(String[] args) throws InterruptedException {
Counter counter = new Counter();

// Create two threads


CounterThread thread1 = new CounterThread(counter);
CounterThread thread2 = new CounterThread(counter);

// Start the threads


[Link]();
[Link]();

// Wait for both threads to nish


[Link]();
[Link]();

// Print the nal count


[Link]("Final count: " + [Link]());
}
}
```

# Explanation:
1. *Synchronized methods*: We declare the `increment()` and `getCount()` methods in the
`Counter` class as `synchronized`. This ensures that only one thread can execute these
methods at a time.
2. *Mutex lock*: When a thread calls a `synchronized` method, it acquires a mutex lock on
the object. Other threads cannot call `synchronized` methods on the same object until the
lock is released.
fi
fi
Assignment 5
3. *Thread safety*: By synchronizing access to the `count` variable, we ensure that the
increment operation is atomic and thread-safe.

# Bene ts:
1. *Prevents race conditions*: Synchronization prevents multiple threads from accessing
shared data simultaneously, avoiding race conditions.
2. *Ensures data consistency*: Synchronization ensures that shared data is consistent and
accurate.

# Key Points:
1. *Use synchronized keyword*: Use the `synchronized` keyword to declare methods or
blocks that require exclusive access to shared data.
2. *Locking mechanism*: Synchronization uses a locking mechanism to ensure that only
one thread can access shared data at a time.
3. *Thread safety*: Synchronization is essential for ensuring thread safety in multithreaded
programs.

Q5: Discuss the advantages of using the HashMap class in Java's Collections Framework.
Provide examples of situations where a HashMap is more suitable than other map
implementations.

SOLUTION : The `HashMap` class in Java's Collections Framework offers several


advantages:

# Advantages of HashMap:
1. *Fast lookup and insertion*: `HashMap` provides fast lookup, insertion, and deletion
operations with an average time complexity of O(1), making it suitable for large datasets.
2. *Ef cient storage*: `HashMap` stores key-value pairs ef ciently, using a hash table data
structure that minimizes memory usage.
3. *Flexible key and value types*: `HashMap` allows any non-null object as a key and any
object as a value, providing exibility in data storage and retrieval.

# Situations where HashMap is more suitable:


1. *Caching*: `HashMap` is suitable for caching frequently accessed data, as it provides
fast lookup and insertion operations.
2. *Data aggregation*: `HashMap` can be used to aggregate data from various sources,
such as counting occurrences of words in a text or aggregating data by category.
3. *Con guration storage*: `HashMap` can be used to store con guration data, such as
user preferences or application settings.

# Comparison with other map implementations:


1. *TreeMap*: `TreeMap` provides a sorted map implementation, which is useful when
data needs to be ordered or sorted. However, `TreeMap` has a slower lookup time
complexity (O(log n)) compared to `HashMap`.
2. *LinkedHashMap*: `LinkedHashMap` provides a map implementation that preserves the
order of insertion, which is useful when data needs to be processed in a speci c order.
However, `LinkedHashMap` may have slower performance compared to `HashMap` due to
the additional overhead of maintaining the linked list.

# Example usage:
```
fi
fi
fi
fl
fi
fi
fi
Assignment 5
import [Link];
import [Link];

public class HashMapExample {


public static void main(String[] args) {
// Create a HashMap
Map<String, Integer> studentGrades = new HashMap<>();

// Insert data into the HashMap


[Link]("John", 85);
[Link]("Alice", 90);
[Link]("Bob", 78);

// Retrieve data from the HashMap


[Link]("John's grade: " + [Link]("John"));

// Update data in the HashMap


[Link]("John", 88);
[Link]("John's updated grade: " + [Link]("John"));
}
}
```

Note: Attempt any two questions from the following [20 Marks Each]

Q7: Design and implement a multithreaded Java program that demonstrates thread
communication using wait(), notify(), or notifyAll(). Provide a detailed explanation of how the
threads communicate

SOLUTION: Here's a Java program that demonstrates thread communication using `wait()`,
`notify()`, and `notifyAll()`:

# Producer-Consumer Problem:
```
import [Link];
import [Link];

class SharedQueue {
private Queue<Integer> queue = new LinkedList<>();
private nal int MAX_SIZE = 5;

public synchronized void produce(int item) throws InterruptedException {


while ([Link]() == MAX_SIZE) {
[Link]("Queue is full. Producer is waiting.");
wait();
}
[Link](item);
[Link]("Produced: " + item);
notifyAll(); // Notify consumers that an item is available
}

public synchronized int consume() throws InterruptedException {


fi
Assignment 5
while ([Link]()) {
[Link]("Queue is empty. Consumer is waiting.");
wait();
}
int item = [Link]();
[Link]("Consumed: " + item);
notifyAll(); // Notify producers that space is available
return item;
}
}

class Producer extends Thread {


private SharedQueue queue;

public Producer(SharedQueue queue) {


[Link] = queue;
}

@Override
public void run() {
try {
for (int i = 1; i <= 10; i++) {
[Link](i);
[Link](100); // Simulate production time
}
} catch (InterruptedException e) {
[Link]().interrupt();
}
}
}

class Consumer extends Thread {


private SharedQueue queue;

public Consumer(SharedQueue queue) {


[Link] = queue;
}

@Override
public void run() {
try {
for (int i = 1; i <= 10; i++) {
[Link]();
[Link](100); // Simulate consumption time
}
} catch (InterruptedException e) {
[Link]().interrupt();
}
}
}

public class Main {


public static void main(String[] args) {
SharedQueue queue = new SharedQueue();
Producer producer = new Producer(queue);
Consumer consumer = new Consumer(queue);
Assignment 5

[Link]();
[Link]();
}
}
```

# Explanation:
1. *SharedQueue class*: This class represents a shared queue that producers and consumers
access. It uses `wait()` and `notifyAll()` to coordinate access to the queue.
2. *Producer thread*: The producer thread produces items and adds them to the queue. If the
queue is full, it waits until space becomes available.
3. *Consumer thread*: The consumer thread consumes items from the queue. If the queue is
empty, it waits until an item becomes available.
4. *wait() and notifyAll()*: These methods are used to coordinate access to the queue. When a
producer or consumer thread is waiting, it releases the lock on the queue, allowing other threads to
access it. When an item is added or removed from the queue, the `notifyAll()` method is called to
wake up waiting threads.

# Thread Communication:
1. *Producer-consumer synchronization*: The producer and consumer threads synchronize access
to the shared queue using `wait()` and `notifyAll()`.
2. *Queue full or empty*: When the queue is full or empty, the producer or consumer thread waits
until the condition changes.
3. *Noti cation*: When an item is added or removed from the queue, the `notifyAll()` method is
called to wake up waiting threads.

Q8: Explore the concepts of deadlocks in multithreading. Explain the key characteristics of
deadlocks and provide strategies for deadlock prevention and handling. Include examples to
support your explanations.

SOLUTION: Deadlocks are a fundamental problem in multithreading that can cause a program to
freeze or become unresponsive. Here's an explanation of deadlocks, their characteristics, and
strategies for prevention and handling:

# What is a Deadlock?
A deadlock is a situation where two or more threads are blocked inde nitely, each waiting for the
other to release a resource. This creates a cycle of dependency, where none of the threads can
proceed.

# Key Characteristics of Deadlocks:


1. *Mutual Exclusion*: Two or more threads require exclusive access to a common resource.
2. *Hold and Wait*: One thread holds a resource and waits for another resource held by another
thread.
3. *No Preemption*: The operating system does not force a thread to release a resource.
4. *Circular Wait*: A cycle of threads exists, where each thread is waiting for a resource held by
another thread.

# Strategies for Deadlock Prevention:


1. *Avoid Nested Locks*: Minimize the use of nested locks, which can lead to deadlocks.
2. *Lock Ordering*: Establish a consistent lock ordering to prevent deadlocks.
3. *Avoid Unnecessary Locks*: Only lock resources when necessary, and release locks as soon as
possible.
4. *Use Lock Timeout*: Use lock timeout mechanisms to detect and recover from deadlocks.
fi
fi
Assignment 5

# Strategies for Deadlock Handling:


1. *Deadlock Detection*: Implement deadlock detection mechanisms to identify deadlocks.
2. *Deadlock Recovery*: Develop strategies for recovering from deadlocks, such as aborting one of
the threads.
3. *Thread Priorities*: Assign priorities to threads to ensure that critical threads are not blocked.

# Example:
```
public class DeadlockExample {
private static nal Object lock1 = new Object();
private static nal Object lock2 = new Object();

public static void main(String[] args) {


Thread thread1 = new Thread(() -> {
synchronized (lock1) {
[Link]("Thread 1: Holding lock 1...");
try {
[Link](100);
} catch (InterruptedException e) {
[Link]().interrupt();
}
[Link]("Thread 1: Waiting for lock 2...");
synchronized (lock2) {
[Link]("Thread 1: Holding lock 1 and lock 2...");
}
}
});

Thread thread2 = new Thread(() -> {


synchronized (lock2) {
[Link]("Thread 2: Holding lock 2...");
try {
[Link](100);
} catch (InterruptedException e) {
[Link]().interrupt();
}
[Link]("Thread 2: Waiting for lock 1...");
synchronized (lock1) {
[Link]("Thread 2: Holding lock 1 and lock 2...");
}
}
});

[Link]();
[Link]();
}
}
```
fi
fi

Common questions

Powered by AI

Thread communication in Java can be managed using wait(), notify(), and notifyAll() methods, which are used to coordinate the execution of threads in a shared object scenario . The wait() method causes the current thread to wait until another thread invokes notify() or notifyAll() on the same object . The notify() method wakes up a single waiting thread, while notifyAll() wakes all waiting threads on that object . These mechanisms are crucial in scenarios like the producer-consumer problem, where a producer thread must wait if the queue is full, and a consumer must wait if the queue is empty . When an item is added or removed, notifyAll() ensures proper synchronization by waking up all waiting threads .

The producer-consumer problem is a classic example in concurrent programming where producers generate data and consumers process it, requiring synchronization to prevent conditions like buffer overflow or underflow . In Java, this can be solved using wait(), notify(), and notifyAll() for thread communication. The producer checks if the queue is full using a while loop with wait(). If not full, it adds items and calls notifyAll() to wake consumer threads. Consumers similarly use wait() when the queue is empty and consume items otherwise, also calling notifyAll() to signal producers . These methods help coordinate and synchronize access to the shared queue, ensuring efficient production and consumption .

Extending the Thread class involves creating a new class that inherits from Thread and overriding the run() method, making the thread tightly coupled to the task . In contrast, implementing the Runnable interface involves creating a class that implements Runnable and providing an implementation for run(), allowing separation of the task from the thread which executes it . While Thread gives direct control over thread methods like join() or interrupt(), Runnable offers more flexibility as it can be run by different thread objects, enhancing reusability and decoupling task execution .

To avoid nested locks and prevent potential deadlocks in a Java multithreaded program, developers should implement practices such as minimizing the use of locks by restructuring code to reduce resource dependency . Establishing a strict lock ordering where locks are acquired and released in a consistent global order can significantly help prevent deadlocks. Implementing fine-grained locking, where possible, should ensure that locks are held for minimal time to reduce contention. Additionally, using higher-level concurrency structures in Java, such as concurrent collections that manage their own locking, can help avert nested locks naturally .

HashMap offers faster performance compared to TreeMap and LinkedHashMap due to its average O(1) time complexity for operations like insertion and lookup, making it suitable for scenarios where order does not matter . TreeMap, based on a Red-Black tree, provides O(log n) time complexity and maintains sorted order, making it ideal for ordered data requirements. LinkedHashMap maintains the insertion order by maintaining a doubly-linked list and is used when iteration order is required, although it may perform slightly slower than HashMap due to this overhead . Use cases for HashMap include large datasets where quick access is needed without concern for order, while TreeMap fits sorting needs and LinkedHashMap suits scenarios necessitating data order retention .

Synchronization in Java helps prevent race conditions by allowing only one thread to execute a synchronized method at a time, thus ensuring that only one thread can access a shared resource simultaneously . Key benefits of synchronized methods include preventing race conditions, ensuring data consistency, and making operations atomic and thread-safe . When a thread calls a synchronized method, it acquires a mutex lock on the object, preventing other threads from accessing synchronized methods on the same object until the lock is released .

Deadlocks in multithreading occur when two or more threads are blocked indefinitely, each waiting for the other to release a resource, creating a cycle of dependency . Key characteristics include mutual exclusion (exclusive access to resources), hold and wait (threads holding resources while waiting for others), no preemption (resources cannot be forcibly taken), and circular wait (a cycle of threads each waiting on another). Strategies for prevention include avoiding nested locks, establishing lock ordering, minimizing lock usage, and using lock timeouts . Handling strategies involve deadlock detection, implementing recovery methods, and adjusting thread priorities .

The Thread class in Java represents a separate flow of execution, where you create a new thread by extending this class and overriding the run() method . The Runnable interface, on the other hand, represents a task that can be executed by a thread and requires implementing the Runnable interface with a run() method . Key differences include inheritance (you cannot extend any other class if you extend Thread, whereas Runnable allows for multiple inheritances), flexibility (Runnable can be passed to different executors or threads), and reusability (Runnable objects can be reused, unlike Thread objects that are tightly coupled). Use Thread when you need direct control over thread execution, such as using join() or interrupt(). Use Runnable for decoupling tasks from execution or needing to pass tasks to various executors or threads .

Synchronized blocks in Java provide control over the synchronization of access to shared resources, allowing more granular control than the synchronized method . By locking only the critical section of code rather than the entire method, synchronized blocks can enhance performance while ensuring that only one thread at a time can execute the block, thus maintaining data consistency and thread safety . This is particularly effective for avoiding race conditions by making specific data updates atomic and ensuring mutual exclusion without overlocking the entire resource, which helps in scenarios where only part of a resource needs protection .

HashMap in Java provides efficient storage and fast lookup, insertion, and deletion operations with an average time complexity of O(1) due to its underlying hash table data structure . It is particularly useful in scenarios such as caching frequently accessed data, data aggregation, and storing configuration data . Its flexibility in allowing any non-null object as a key and any object as a value makes it suitable for various applications . HashMap is more suitable than TreeMap or LinkedHashMap in cases where data order or insertion order is not a concern .

You might also like