Thread Interrupt Demo

✳𝐢𝐧𝐭𝐞𝐫𝐫𝐮𝐩𝐭, 𝐢𝐬𝐈𝐧𝐭𝐞𝐫𝐫𝐮𝐩𝐭𝐞𝐝, 𝐢𝐧𝐭𝐞𝐫𝐫𝐮𝐩𝐭𝐞𝐝
✅𝑰𝒏𝒕𝒆𝒓𝒓𝒖𝒑𝒕𝒔 𝒂𝒓𝒆 𝒄𝒐-𝒐𝒑𝒆𝒓𝒂𝒕𝒊𝒗𝒆 𝒎𝒆𝒄𝒉𝒂𝒏𝒊𝒔𝒎𝒔 𝒇𝒐𝒓 𝒔𝒆𝒏𝒅𝒊𝒏𝒈 𝒔𝒕𝒐𝒑 𝒔𝒊𝒈𝒏𝒂𝒍 𝒕𝒐 𝒂 𝒍𝒐𝒏𝒈 𝒓𝒖𝒏𝒏𝒊𝒏𝒈 𝒕𝒉𝒓𝒆𝒂𝒅.
✅𝑰𝒕 𝒊𝒔 𝒏𝒐𝒕 𝒂 𝒇𝒐𝒓𝒄𝒆𝒇𝒖𝒍 𝒘𝒂𝒚 𝒕𝒐 𝒄𝒂𝒏𝒄𝒆𝒍 𝒕𝒉𝒆 𝒕𝒉𝒓𝒆𝒂𝒅.
✅𝙄𝙩 𝙞𝙨 𝙟𝙪𝙨𝙩 𝙡𝙞𝙠𝙚 𝙖 𝙥𝙤𝙡𝙞𝙩𝙚 𝙤𝙧𝙙𝙚𝙧 𝙛𝙧𝙤𝙢 𝙤𝙣𝙚 𝙩𝙝𝙧𝙚𝙖𝙙 𝙩𝙤 𝙖𝙣𝙤𝙩𝙝𝙚𝙧 𝙩𝙤 𝙨𝙩𝙤𝙥 𝙥𝙧𝙤𝙘𝙚𝙨𝙨𝙞𝙣𝙜 𝙛𝙪𝙧𝙩𝙝𝙚𝙧 𝙪𝙨𝙞𝙣𝙜 𝙞𝙣𝙩𝙚𝙧𝙧𝙪𝙥𝙩.
✅𝒊𝒕 𝒅𝒐𝒆𝒔𝒏’𝒕 𝒂𝒄𝒕𝒖𝒂𝒍𝒍𝒚 𝒊𝒏𝒕𝒆𝒓𝒓𝒖𝒑𝒕 𝒂 𝒓𝒖𝒏𝒏𝒊𝒏𝒈 𝒕𝒉𝒓𝒆𝒂𝒅 — 𝒊𝒕 𝒋𝒖𝒔𝒕 𝒓𝒆𝒒𝒖𝒆𝒔𝒕𝒔 𝒕𝒉𝒂𝒕 𝒕𝒉𝒆 𝒕𝒉𝒓𝒆𝒂𝒅 𝒊𝒏𝒕𝒆𝒓𝒓𝒖𝒑𝒕 𝒊𝒕𝒔𝒆𝒍𝒇 𝒂𝒕 𝒕𝒉𝒆 𝒏𝒆𝒙𝒕 𝒄𝒐𝒏𝒗𝒆𝒏𝒊𝒆𝒏𝒕 𝒐𝒑𝒑𝒐𝒓𝒕𝒖𝒏𝒊𝒕𝒚.
✅𝑻𝒉𝒆𝒓𝒆 𝒂𝒓𝒆 𝒔𝒆𝒗𝒆𝒓𝒂𝒍 𝒓𝒆𝒂𝒔𝒐𝒏 𝒇𝒐𝒓 𝒕𝒉𝒓𝒆𝒂𝒅 𝒃𝒍𝒐𝒄𝒌:-
𝑾𝒂𝒊𝒕𝒊𝒏𝒈 𝒕𝒐 𝒘𝒂𝒌𝒆 𝒖𝒑 𝒇𝒓𝒐𝒎 𝑻𝒉𝒓𝒆𝒂𝒅.𝒔𝒍𝒆𝒆𝒑()
𝑾𝒂𝒊𝒕𝒊𝒏𝒈 𝒕𝒐 𝒂𝒄𝒒𝒖𝒊𝒓𝒆 𝒍𝒐𝒄𝒌.
𝑾𝒂𝒊𝒕𝒊𝒏𝒈 𝒇𝒐𝒓 𝑰/𝑶 𝒄𝒐𝒎𝒑𝒍𝒆𝒕𝒊𝒐𝒏
𝑾𝒂𝒊𝒕𝒊𝒏𝒈 𝒇𝒐𝒓 𝒕𝒉𝒆 𝒓𝒆𝒔𝒖𝒍𝒕 𝒐𝒇 𝒂 𝒄𝒐𝒎𝒑𝒖𝒕𝒂𝒕𝒊𝒐𝒏 𝒊𝒏 𝒂𝒏𝒐𝒕𝒉𝒆𝒓 𝒕𝒉𝒓𝒆𝒂𝒅, 𝒂𝒎𝒐𝒏𝒈 𝒐𝒕𝒉𝒆𝒓𝒔.
✅𝑻𝒉𝒆𝒓𝒆 𝒂𝒓𝒆 𝒔𝒆𝒗𝒆𝒓𝒂𝒍 𝒎𝒆𝒕𝒉𝒐𝒅𝒔 𝑻𝒉𝒓𝒆𝒂𝒅.𝒔𝒍𝒆𝒆𝒑(), 𝑻𝒉𝒓𝒆𝒂𝒅.𝒋𝒐𝒊𝒏(), 𝒕𝒉𝒆 𝒘𝒂𝒊𝒕() 𝒎𝒆𝒕𝒉𝒐𝒅 𝒐𝒇 𝒐𝒃𝒋𝒆𝒄𝒕 𝒄𝒍𝒂𝒔𝒔, 𝒑𝒖𝒕 𝒂𝒏𝒅 𝒕𝒂𝒌𝒆() 𝒎𝒆𝒕𝒉𝒐𝒅 𝒐𝒇 𝑩𝒍𝒐𝒄𝒌𝒊𝒏𝒈𝑸𝒖𝒆𝒖𝒆.
✅𝑾𝒆 𝒄𝒂𝒏 𝒂𝒍𝒍𝒐𝒘 𝒕𝒉𝒆 𝑰𝒏𝒕𝒆𝒓𝒓𝒖𝒑𝒕𝒆𝒅𝑬𝒙𝒄𝒆𝒑𝒕𝒊𝒐𝒏 𝒕𝒐 𝒑𝒓𝒐𝒑𝒂𝒈𝒂𝒕𝒆 𝒖𝒑 𝒕𝒉𝒆 𝒄𝒂𝒍𝒍 𝒔𝒕𝒂𝒄𝒌, 𝒇𝒐𝒓 𝒆𝒙𝒂𝒎𝒑𝒍𝒆, 𝒃𝒚 𝒂𝒅𝒅𝒊𝒏𝒈 𝒂 𝒕𝒉𝒓𝒐𝒘𝒔 𝒄𝒍𝒂𝒖𝒔𝒆 𝒕𝒐 𝒆𝒂𝒄𝒉 𝒎𝒆𝒕𝒉𝒐𝒅 𝒊𝒏 𝒕𝒖𝒓𝒏 𝒂𝒏𝒅 𝒍𝒆𝒕𝒕𝒊𝒏𝒈 𝒕𝒉𝒆 𝒄𝒂𝒍𝒍𝒆𝒓 𝒅𝒆𝒕𝒆𝒓𝒎𝒊𝒏𝒆 𝒉𝒐𝒘 𝒕𝒐 𝒉𝒂𝒏𝒅𝒍𝒆 𝒕𝒉𝒆 𝒊𝒏𝒕𝒆𝒓𝒓𝒖𝒑𝒕. 𝑻𝒉𝒊𝒔 𝒄𝒂𝒏 𝒊𝒏𝒗𝒐𝒍𝒗𝒆 𝒐𝒖𝒓 𝒏𝒐𝒕 𝒄𝒂𝒕𝒄𝒉𝒊𝒏𝒈 𝒕𝒉𝒆 𝒆𝒙𝒄𝒆𝒑𝒕𝒊𝒐𝒏 𝒐𝒓 𝒄𝒂𝒕𝒄𝒉𝒊𝒏𝒈 𝒂𝒏𝒅 𝒓𝒆𝒕𝒉𝒓𝒐𝒘𝒊𝒏𝒈 𝒊𝒕.
✅𝒊𝒔𝑰𝒏𝒕𝒆𝒓𝒓𝒖𝒑𝒕𝒆𝒅:- 𝒄𝒉𝒆𝒄𝒌 𝒕𝒉𝒆 𝒊𝒏𝒕𝒆𝒓𝒓𝒖𝒑𝒕 𝒇𝒍𝒂𝒈
𝒊𝒏𝒕𝒆𝒓𝒓𝒖𝒑𝒕𝒆𝒅:- 𝒄𝒉𝒆𝒄𝒌 𝒕𝒉𝒆 𝒇𝒍𝒂𝒈 𝒂𝒏𝒅 𝒓𝒆𝒔𝒆𝒕 𝒊𝒕

public class ThreadInterruptionDemo implements Runnable {
public static void main(String[] args) {
Runnable runnable = new ThreadInterruptionDemo();
Thread t1 = new Thread(runnable);
t1.start();
//main thread is sleeping
try {
Thread.sleep(2000);
System.out.println(“From main — Interrupting other thread”);
t1.interrupt();
t1.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(“in main() — leaving”);
}
@Override
public void run() {
System.out.println(“Inside run method of ThreadInterruptionDemo”);
System.out.println(“Calling doProcess method”);
try {
doProcess();
} catch (InterruptedException e) {
System.out.println(“in run() — interrupted in doProcess()”);
return;
}
System.out.println(“in run() — doing stuff after nap”);
System.out.println(“in run() — leaving normally”);
}
private void doProcess() throws InterruptedException {
while(true) {
System.out.println(“doProcess method is running”);
//poll for interrupts since other thread interrupts this thread
if(Thread.currentThread().isInterrupted()) {
System.out.println(“isInterrupted() = “ + Thread.currentThread().isInterrupted());
System.out.println(“Stopping the task”);
//calling below line will reset isInterrupted flag
//System.out.println(“interrupted = “ + Thread.interrupted());
TimeUnit.SECONDS.sleep(1);
System.out.println(“This line will not run”);
}
}
}
}

Example 2:-

public class ThreadInterruptedExample2 extends Thread {
public static void main(String[] args) {
System.out.println(restoreTheState());
}
public static Boolean restoreTheState() {
ThreadInterruptedExample2 thread1 = new ThreadInterruptedExample2();
thread1.start();
thread1.interrupt();
return thread1.isInterrupted();
}
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt(); //set the flag back to <code>true
}
}
}

Example 3:-

public class ThreadInterruptedExample {
public static void main(String[] args) {
// TODO Auto-generated method stub
try {
propagateException();
} catch (InterruptedException e) {
System.out.println(“Exception”);
e.printStackTrace();
}
}
public static void propagateException() throws InterruptedException {
Thread.sleep(1000);
Thread.currentThread().interrupt();
if(Thread.currentThread().isInterrupted()) {
throw new InterruptedException();
}
}
}

============= Learn Is Always Be Fun ==============