What happens when you invoke a thread’s interrupt method while it is sleeping or waiting?

by

When a task’s interrupt() method is executed, the task enters the ready state. The next time the task enters the running state, an InterruptedException is thrown.

When you invoke a thread’s interrupt method while it is sleeping or waiting, it will cause the thread to receive an InterruptedException. This interruption can be used to gracefully stop the thread or perform cleanup operations.

If a thread is in the sleeping state when interrupt is called, it will wake up from its sleep, throw an InterruptedException, and continue its execution. If the thread is in the waiting state (e.g., waiting on an object’s monitor), it will also throw an InterruptedException.

It’s important to note that if the thread is not in a state where it can be interrupted (for example, if it’s not sleeping or waiting), invoking interrupt will have no immediate effect. However, it will set the thread’s interrupt status, and the thread can check its interrupt status using Thread.interrupted().

Here’s a simple example to illustrate:

java
public class MyThread extends Thread {
public void run() {
try {
// Some task that involves sleeping or waiting
Thread.sleep(5000); // Sleeping for 5 seconds
} catch (InterruptedException e) {
// Handle interruption
System.out.println("Thread interrupted!");
return;
}
System.out.println("Thread completed its task.");
}

public static void main(String[] args) {
MyThread myThread = new MyThread();
myThread.start();

// After some time, interrupt the thread
try {
Thread.sleep(2000); // Sleep for 2 seconds
} catch (InterruptedException e) {
e.printStackTrace();
}

myThread.interrupt(); // Interrupt the thread
}
}

In this example, the main thread starts a new thread (MyThread), and after 2 seconds, it interrupts the new thread. The interrupted thread reacts to the interruption by catching the InterruptedException and printing a message.