java并发编程:线程中断方法interrupt详解

Published on 2024-06-14 15:32 in 分类: 博客 with 狂盗一枝梅
分类: 博客

java.lang.Thread类有一个 interrupt 方法,该方法直接对线程调用。当被interrupt的线程正在sleep或wait时,会抛出 InterruptedException 异常。事实上, interrupt 方法只是改变目标线程的中断状态(interrupt status),而那些会抛出InterruptedException 异常的方法,如wait、sleep、join等,都是在方法内部不断地检查中断状态的值,如果发现中断,则抛出InterruptedException异常。

interrupt方法

Thread实例方法:必须由其它线程获取被调用线程的实例后,进行调用。实际上,只是改变了被调用线程的内部中断状态;

Thread.interrupted方法

Thread类方法:必须在当前执行线程内调用,该方法返回当前线程的内部中断状态,然后清除中断状态(置为false) ;

isInterrupted方法

Thread实例方法:用来检查指定线程的中断状态。当线程为中断状态时,会返回true;否则返回false。

上面的一些说法比较抽象,为了验证上述说法,写几个demo来验证一下。

一、中断和中断检查

1、interrupt方法可能不会中断线程

首先得明确第一个问题:interrupt方法是用于中断线程的方法,但是实际如果线程内没有sleep等阻塞方法,它实际上并不会中断线程,就算有sleep等方法执行,但是如果将异常捕获了,那它也不会中断线程的执行。看以下代码:

public class ThreadTest1 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Task("mytask"));
        t.start();
        t.interrupt();
    }

    static class Task implements Runnable {
        String name;

        public Task(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            int i = 0;
            while (true) {
                System.out.println(i++);
            }
        }
    }
}

运行该程序,将会进入死循环,不断打印i的自增值,最后整型溢出也不会停止,主线程调用的interrupt方法根本无法阻止线程继续运行。

正是之前所说的,“interrupt方法只是改变了被调用线程的内部中断状态“,那如何检查线程的中断状态呢?

2、isInterrupted实例方法检查中断状态

接下来我们调用Thread类的isInterrupted实例方法来检查线程的中断状态

public class ThreadTest2 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Task("mytask"));
        t.start();
        t.interrupt();
    }

    static class Task implements Runnable {
        String name;

        public Task(String name) {
            this.name = name;
        }   

        @Override
        public void run() {
            //检查两次中断状态,都是true
            System.out.println("first:"+Thread.currentThread().isInterrupted());
            System.out.println("second:"+Thread.currentThread().isInterrupted());
            System.out.println("task " + name + " is over");
        }
    }
}

上述代码的运行结果如下

first:true
second:true
task mytask is over

主线程调用了中断方法,线程内调用线程的isInterrupted方法,输出都是true,表示都检测到了中断。为什么要输出两次一模一样的检测结果呢?是为了验证第一次调用的isInterrupted方法并没有改变中断状态。

3、interrupted静态方法检查中断状态

interrupted方法是Thread类的静态方法,它也能检查当前线程的中断状态,但是只能检查一次:这个静态方法有个天坑,它返回中断状态之后,会将中断标志复位成false,所以第二次调用该静态方法就会发现中断标志被改变了。

public class ThreadTest3 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Task("mytask"));
        t.start();
        t.interrupt();
    }

    static class Task implements Runnable {
        String name;

        public Task(String name) {
            this.name = name;
        }   

        @Override
        public void run() {
            //第一次调用返回中断状态,并将中断状态复位
            System.out.println("first :" + Thread.interrupted());
            //第二次调用返回复位后的中断状态
            System.out.println("second:" + Thread.interrupted());
            System.out.println("task " + name + " is over");
        }
    }
}

中断代码的输出结果为

first :true
second:false
task mytask is over

可以看到,重复调用Thread.interrupted()方法,得到的结果并不一样,原因就是第一次调用的时候中断状态被复位了。

二、中断抛异常的情况讨论

1、阻塞中断并抛出异常

既然是中断方法,那它肯定能在某些情况下中断线程的执行,什么情况下呢?就是在大多数阻塞方法下,比如线程正在sleep、wait、join等。

看下以下代码示例

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Task("mytask"));
        t.start();
        t.interrupt();
    }

    static class Task implements Runnable {
        String name;

        public Task(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                System.out.println("thread has been interrupt!");
            }
//            阻塞情况下中断,抛出异常后线程恢复非中断状态,即 interrupted = false
            System.out.println("isInterrupted: " +
                    Thread.currentThread().isInterrupted());
            System.out.println("task " + name + " is over");
        }
    }
}

它的运行结果如下

thread has been interrupt!
isInterrupted: false
task mytask is over

线程在sleep期间被中断并抛出了InterruptedException异常,抛出异常后立即重置了中断状态,所以接下来的检查中断方法得到的结果是false

2、interrupted不会中断锁阻塞

对于sleep等阻塞方法,遇到interrupt中断方法会抛出异常,但是对于锁阻塞,则不会,看以下案例

public class ThreadTest4 {
    public static void main(String[] args) throws InterruptedException {
        Task mytask = new Task("mytask");
        Thread t1 = new Thread(mytask);
        Thread t2 = new Thread(mytask);
        t1.start();
        t2.start();
        t2.interrupt();
    }

    static class Task implements Runnable {
        String name;

        public Task(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            synchronized (this) {
                System.out.println(new Date() + ":" + Thread.currentThread().getName() + ": start run");
                try {
                    Thread.sleep(3000L);
                } catch (InterruptedException e) {
                    System.out.println(new Date() + ":" + Thread.currentThread().getName() + ":catch interrupted exception");
                
                }
            }
            System.out.println(new Date() + ":" + Thread.currentThread().getName() + ":" + Thread.currentThread().isInterrupted());
        }
    }
}

该程序运行结果如下

Fri Jun 14 15:11:52 CST 2024:Thread-0: start run
Fri Jun 14 15:11:55 CST 2024:Thread-1: start run
Fri Jun 14 15:11:55 CST 2024:Thread-0:false
Fri Jun 14 15:11:55 CST 2024:Thread-1:catch interrupted exception
Fri Jun 14 15:11:55 CST 2024:Thread-1:false

线程0持有锁之后等待了3秒钟,在等待期间,线程1尝试进入方法区,但是拿不到锁,所以进不去,进入锁等待状态,这时候主线程调用了线程1的线程中断方法interrupt,但是线程1并没有任何反映,等待线程0释放了锁之后,拿到锁,这时候它开始执行sleep方法,由于线程中断,抛出了InterruptedException,所以它“没睡”,直接打印信息后结束了线程。

如果我们不想线程1抛出异常,该怎么做呢?其实只需要稍微修改一点代码:

System.out.println(new Date() + ":" + Thread.currentThread().getName() + ": start run");

将上面这行代码改成下面这样子

System.out.println(new Date() + ":" + Thread.currentThread().getName() +":" + Thread.interrupted() + ": start run");

只是进入方法区之后加了一点点逻辑:Thread.interrupted()

再次执行上面的主方法,得到的结果为

Fri Jun 14 15:20:09 CST 2024:Thread-0:false: start run
Fri Jun 14 15:20:12 CST 2024:Thread-1:true: start run
Fri Jun 14 15:20:12 CST 2024:Thread-0:false
Fri Jun 14 15:20:15 CST 2024:Thread-1:false

现成1不抛异常了,而且正常等待了3秒钟。。。可见,Thread.interrupted方法真是个隐藏的bug方法啊

三、总结

1、调用interrupt方法中断线程实际上只是设置了中断标志,只有线程在执行sleep、wait等阻塞的方法的时候才会抛出中断异常,但是并不会中断锁阻塞;中断抛出异常后会重置中断状态为false

2、可以调用Thread类的isInterrupted实例方法检测线程的中断状态,该方法不会重置中断状态为false

3、可以调用Thread类的interrupted静态方法检测线程的中断状态,该方法会重置中断状态为false,所以要慎用。


#java #并发编程
目录