JavaEE 第3节 线程安全知识铺垫2

Java中线程终止的方式

下面代码我们创建了一个thread线程，如何在main线程（main方法中）终止thread线程？

1、手动标记

public class Threads {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            while (true) {
                System.out.println("我是thread线程");
            }
        });

        thread.start();

        //如何在main线程（main方法中）终止thread线程？
    }
}

有一个很简单的办法，就是做一个标记：

public class Threads {

    //定义一个变量，来判断是否终止线程
    private static boolean isQuit=true;

    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            while (isQuit) {
                System.out.println("我是thread线程");
            }
        });

        thread.start();

        System.out.println("主线程即将终止thread线程的运行");
        isQuit=false;
        System.out.println("主线程终止了thread线程");
        //如何在main线程（main方法中）终止thread线程？
    }
}

的确，thread线程被终止了：

这种方法可行，但是注意不要把isQuit定义在main方法中，不然会报错：

原因在于我们创建线程用到了lambda表达式（本质还是匿名内部类创建），如果把isQuit定义在main方法内部，那么就会触发变量捕获，提示说isQuit必须是final或者effectively final的，这个细节大家要注意。

2、interrupt()建立标志位

除了这种手动创建标志位的方式，Java在Thread类中提供了interrupt（）方法来告诉需要中断的线程你该结束了。

还是用刚才的代码进行修改：

public class Threads {
    public static void main(String[] args) {

        Thread thread = new Thread(() -> {
            Thread curThread = Thread.currentThread();//这个方法可以获取当前线程的对象！(此时获取的是thread线程的对象)
            //isInterrupted()如果中断了，就返回真，否则返回假
            while (!curThread.isInterrupted()) {
                System.out.println("我是thread线程");
            }
        });

        thread.start();
        System.out.println("主线程即将终止thread线程的运行");
        thread.interrupt();//这个方法把isInterrupted设置成true
        System.out.println("主线程终止了thread线程");
    }
}

注意：

之所以要用currentThread()方法获取当前线程对象，原因在于lambda表达式内部thread线程的对象都还没有创建完成，如果直接使用thread，是会报错的。

通过interrupt方法，我们同样完成了线程的终止。

细心的小伙伴一定发现，我刚才特意把“告诉”这个关键词进行了加粗、下划线注释，这里肯定是有原因的：

原因在于Thread类中的interrupt()方法中断线程的方式比较“柔和”。

它会给线程设置一个中断标志，告诉这个线程你要尽快结束并终止，而不是直接“杀死”这个线程（不是直接终止这个线程）

我们用一个例子演示就明白了：

编写一个程序：

创建一个线程thread，thread线程每隔1秒（总共10次），打印一句话。

然后在主线程通过interrupt方法终止这个线程。

public class Threads {
    public static void main(String[] args) throws InterruptedException {

        Thread thread = new Thread(() -> {
            Thread curThread = Thread.currentThread();//这个方法可以获取当前线程的对象！(此时获取的是thread线程的对象)
            //isInterrupted()如果中断了，就返回真，否则返回假
            while (!curThread.isInterrupted()) {
                for (int i = 0; i <10 ; i++) {
                    try {
                        System.out.println("开始睡眠"+(i+1)+"次");
                        System.out.println();
                        Thread.sleep(1000);//sleep方法可以让线程进入休眠（不占用cpu）单位是ms
                    } catch (InterruptedException e) {

                        System.out.println("捕获到了中断异常");

                            curThread.interrupt();//重新设置标志位
                    }
                }
            }
        });

        thread.start();
        //主线程休眠2秒，确保子线程tread能成功被调度（因为系统调度是”随机的“）
        Thread.sleep(2000);
        thread.interrupt();//在主线程把thread线程终止
    }
}

凭直觉，既然调用了interrupt方法，那么thread线程就不可能执行10次对吧，但是：

为什么？

不着急，我们慢慢来讲。

请看这段代码：

//先清楚标志位,然后抛出异常
public class Threads {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            Thread curThread = Thread.currentThread();
            int i = 0;

            while (!curThread.isInterrupted()) {
                try {
                    Thread.sleep(1000);
                    i++;
                    System.out.println("子线程第" + (i + 1) + "次执行");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    System.out.println("捕获到了异常,但是没有做任何操作");

                }
            }
        });

        thread.start();
        Thread.sleep(1000);
        thread.interrupt();//主线程告诉thread线程,你要结束了
    }
}

这个程序是创建一个thread线程，每隔一秒打印一次信息。

然后通过主线程中断thread线程。

但是执行结果确是一个死循环：

catch捕获到了异常，所以标志位肯定是设置好了的，即while条件中的!curThread.isInterrupted()
应该等于false啊，循环应该退出才对，为什么还会死循环呢？

*sleep()方法的特殊性

原因：

问题的关键点其实在于Thread.sleep（）这个方法。

当一个线程正在睡眠时，如果设置了中断标志位（调用了interrupt方法），那么sleep会

清除标志位（即isInterrupted()=flase）
抛出中断异常
小伙伴们可能会觉得有点奇怪在这个设定上，使用thread.interrupt的方法，目的就是为了让thread.isInterrupted()=true，你怎么就又把它恢复成原来的值呢？

实际上这就是Java对于中断线程”柔和“处理的表现。

主线程依靠这种方式"告诉"thread线程，你要结束了。

至于是否结束，取决与catch语句的具体操作了。

如果catch语句只是打印一下异常信息，其他什么都不干，那么就会出现死循环，因为sleep清空了标志位while的条件恢复成了true。

假如我们在catch语句中，添加return语句，或者重新设置标志位，那么thread线程就不会出现死循环了：

public class Threads {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            Thread curThread = Thread.currentThread();
            int i = 0;

            while (!curThread.isInterrupted()) {
                try {
                    Thread.sleep(1000);
                    i++;
                    System.out.println("子线程第" + (i + 1) + "次执行");
                } catch (InterruptedException e) {
                    e.printStackTrace();
//                    System.out.println("捕获到了异常,但是没有做任何操作");

                    return;//抛出中断异常，那就直接退出线程
                }
            }
        });

        thread.start();
        Thread.sleep(1000);
        thread.interrupt();//主线程告诉thread线程,你要结束了
    }
}

执行结果：

如果以上逻辑都理解啊清楚了，那么接下来要讲的这个现象大家就好理解了：

实际上，上面给的这个程序，不加return，也是有概率退出死循环的！

这并不玄学，听我慢慢把他讲清楚就明白了。

刚才我们讲了Thread.sleep()这个方法很特殊，它不仅可以让当前调用它的线程进入休眠，而且在休眠期间如果其他线程设置了interrupt()标志位，它还会清除标志位、抛出中断异常。这是我们刚才所讲到的最重要的知识点。

那么有没有这样一种情况：

恰好thread线程执行到21行：

主线程执行了thread.interrupt()。那么这个标志位会生效吗？

答案当然是不会，因为thread线程已经睡眠了1秒。之后try块肯定不会抛出InterruptedException。

进而while的条件成功改成了false，thread线程结束。

出现所谓“概率”主要就是因为这两个线程的执行时机是不确定的，既线程调度的不确定性。

具体到这个程序中就是，不知道thread线程中try块的那个位置主线程的interrupt()方法被调度执行。如果在sleep期间，那么就会死循环，如果在sleep完之后，就不会死循环。

完