/**
*isInterrupted
*/
public class InterruptDemo {
public static void main(String[] args) throws InterruptedException{
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
while (!Thread.currentThread().isInterrupted()){
System.out.println(Thread.currentThread()+"没被中断");
}
}
});
thread.start();
Thread.sleep(1000);
System.out.println("main thread interrupt thread");
thread.interrupt();
thread.join();
System.out.println("main is over");
//...
//Thread[Thread-0,5,main]没被中断
//Thread[Thread-0,5,main]没被中断
//Thread[Thread-0,5,main]没被中断
//Thread[Thread-0,5,main]没被中断
//Thread[Thread-0,5,main]没被中断
//main thread interrupt thread
//Thread[Thread-0,5,main]没被中断
//main is over
}
}
/**
* interrupt（）方法打断线程的休眠
*/
public class InterruptDemo2 {
public static void main(String[] args) throws InterruptedException{
Thread threadOne = new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println("threadOne begin sleep for 200 s");
Thread.sleep(200000);
System.out.println("threadOne waking");
} catch (InterruptedException e) {
System.out.println("threadOne is interrupted while sleeping");
return;
}
System.out.println("threadOne-leaving normally");
}
});
threadOne.start();
//确保子线程进入休眠状态
Thread.sleep(1000);
//打断子线程的休眠，让子线程从sleep函数返回
threadOne.interrupt();
//等待子线程执行完毕
threadOne.join();
System.out.println("main thread is over");
//threadOne begin sleep for 200 s
//threadOne is interrupted while sleeping
//main thread is over
// threadOne 线程休眠了200s，在正常情况下该线程需要等到 200s 后才会被唤醒，
// 但是通过调用 threadOne.interrupt（）方法打断了该线程的休眠，
// 该线程会在调用 sleep 方法处抛出 InterruptedException 异常后返回
}
}
/**
* interrupted（） 与 isInterrupted（）
*/
public class InterruptDemo3 {
public static void main(String[] args) throws InterruptedException{
Thread threadOne = new Thread(new Runnable() {
@Override
public void run() {
while (true){}
}
});
threadOne.start();
threadOne.interrupt();
System.out.println("isInterrupted:"+threadOne.isInterrupted());
System.out.println("isInterrupted:"+threadOne.interrupted());
System.out.println("isInterrupted:"+Thread.interrupted());
System.out.println("isInterrupted:"+threadOne.isInterrupted());
threadOne.join();
System.out.println("main thread is over");
//isInterrupted:true
//isInterrupted:false
//isInterrupted:false
//isInterrupted:true
// 在 interrupted（）内部是获取当前调用线程的中断标志而不是调用 interrupted（）方法的实例对象的中断标志。
// public static boolean interrupted() {
// return currentThread().isInterrupted(true);
// }
//在 interrupted（）方法内部是获取当前线程的中断状态，这里虽然调用了 threadOne 的 interrupted（） 方法，
//但是获取的是主线程的中断标志，因为主线程是 当前线程。 threadOne.interrupted（）和 Thread.interrupted（）方法的作用是一样的，
// 目的都是 获取当前线程的中断标志
}
}
/**
* interrupted()
*/
public class InterruptDemo4 {
public static void main(String[] args) throws InterruptedException{
Thread threadOne = new Thread(new Runnable(){
@Override
public void run() {
//中断标志为true时会退出循环，并清除中断标志
while (!Thread.currentThread().interrupted()){}
System.out.println("threadOne interrupted："+Thread.currentThread().isInterrupted());
}
});
threadOne.start();
threadOne.interrupt();
threadOne.join();
System.out.println("main thread is over");
//threadOne interrupted：false
//main thread is over
}
}
补充案例：
public class InterruptTest01 {
public static void main(String[] args) throws InterruptedException{
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
while (true){
System.out.println("hello");
Thread.yield();
}
}
});
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
while (true){
System.out.println("hello");
if (Thread.currentThread().isInterrupted()){
System.out.println("中断...");
break;
}
Thread.yield();
}
}
});
// thread.start();
// Thread.sleep(2000);
// thread.interrupt();
//hello
//hello
//hello
//hello
//hello
//hello
//hello
//...
//虽然对thread进行了中断，但在thread中没有中断处理逻辑，因此，即使thread被置上了中断状态，也不会发生任何作用
// thread2.start();
// Thread.sleep(1000);
// thread2.interrupt();
//hello
//hello
//hello
//hello
//hello
//hello
//中断...
//在循环体中，出现类似于wait(),sleep()这样的操作，则只能通过中断来识别了
//sleep()会抛出InterruptedException，当线程在sleep时被中断，就会产生这个异常
Thread thread3 = new Thread(new Runnable() {
@Override
public void run() {
while (true){
System.out.println("hello");
if (Thread.currentThread().isInterrupted()){
System.out.println("中断...");
break;
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// e.printStackTrace();
//加处理
System.out.println("处理异常");
Thread.currentThread().interrupt(); //再次中断自己，置上中断标记位
}
Thread.yield();
}
}
});
thread3.start();
Thread.sleep(1000);
thread3.interrupt();
//hello
//hello
//hello
//hello
//hello
//hello
//java.lang.InterruptedException: sleep interrupted
// at java.lang.Thread.sleep(Native Method)
// at com.combat.InterruptTest01$3.run(InterruptTest01.java:63)
// at java.lang.Thread.run(Thread.java:748)
//hello
//hello
//hello
//Thread.sleep()方法由于中断而抛出异常，她会清除中断标记，不加处理，那么下次循环就无法捕获这个中断
//处理后结果
//hello
//hello
//hello
//hello
//hello
//hello
//hello
//hello
//hello
//处理异常
//hello
//中断...
}
}