2022/10/10 西安 java多线程（四）守护线程、线程中断机制

守护线程

当所有线程都运行结束时，JVM退出，进程结束。如果有一个线程没有退出，JVM进程就不会退出。所以，必须保证所有线程都能及时结束

守护线程是指为其他线程服务的线程。在JVM中，所有非守护线程都执行完毕后，无论有没有守护线程，虚拟机都会自动退出

Java线程分为俩大类：

1. 用户线程
2. 守护线程（守护线程也叫精灵线程）

守护线程（Daemon）就是运行在程序后台的线程。一般被用于在后台为其他线程提供服务，如垃圾回收线程。

当一个应用程序的所有用户线程停止运行时，即使有守护线程还在运行，该应用程序也将终止；

反过来，只有要用户线程还在运行，应用程序就不会停止。

故守护线程特点：

 一般守护线程是一个死循环，所有的用户线程只要结束，守护线程就会自动结束。

可以通过setDaemon（boolean on）来设置某线程为守护线程，用isDaemon来判断某线程是否为守护线程。

注意：要想设置一个线程为守护线程，setDaemon必须在start前调用。

---

线程中断

如果线程需要执行一个长时间任务，就可能需要能中断线程。中断线程就是其他线程给该线程发一个信号，该线程收到信号后结束执行run()方法，使得自身线程能立刻结束运行

线程终止的原因有：

• 线程正常终止：run()方法执行到return语句返回；
• 线程意外终止：run()方法因为未捕获的异常导致线程终止；
• 对某个线程的Thread实例调用stop()方法强制终止（强烈不推荐使用）。

线程中断机制

一个线程不应该由其他线程来强制中断或停止，而是应该由线程自己自行停止，自己来决定自己的命运。所以，Thread.stop,Thread.suspend,Thread.resume都已经被废弃了。因为方法调用时不会释放所持有的锁，容易出现死锁现象。

Java提供了一种用于停止线程的协商机制一一中断，也即中断标识协商机制。

每个线程对象中都有一个中断标识位，用于表示线程是否被中断；

1. 该标识位为true表示中断，
2. 为false表示未中断。

---

Thread类线程中断api

public void interrupt（）

该方法是一个实例方法，调用该方法的作用：仅仅是设置中断标志为true，发起一个协商而不会立刻停止线程；该方法可以在别的线程中调用，也可以在自己的线程中调用。

public static boolean interrupted()

该方法是一个静态方法，Thread. interrupted();该方法用于判断当前线程是否被中断并将当前线程的中断标志重新设置为FALSE，清除线程中断状态

public boolean isInterrupted()

该方法是一个实例方法，通过检查中断标志，判断线程是否被中断

---

interrupt()中断线程

只需要在其他线程中对目标线程调用interrupt()方法设置中断标志为true，目标线程需要反复检测自身状态是否是interrupted状态，如果是，就立刻结束运行

需要注意的是，当方法体中的代码抛出InterruptedException异常时，线程的中断标志位会复位成         false，若不处理，外部中断线程时，内部也无法停止，所以在catch代码中手动处理，将线程中断

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        //在线程体中对线程的中断标志位进行判断，若线程中断，则不再执行
        while (!Thread.currentThread().isInterrupted()) {
            try {
                //
                System.out.println("t1线程下载文件——龟速");
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
                //发生InterruptedException异常时，在catch中处理，中断线程
                Thread.currentThread().interrupt();
            }
        }
    }, "t1");
    t1.start();
    //暂停20ms
    TimeUnit.MILLISECONDS.sleep(20);
    new Thread(() -> {
        System.out.println("t2线程设置t1线程的中断标志为true");
        t1.interrupt();//设置中断标志为true
    }, "t2").start();
}

这块真的很难受，因为网上所有的实现都是使用while循环。。可实际上在正常情况下怎么会让业务逻辑一直循环等到被打断呢。一直循环是什么鬼嘛。。。。

我自己的改进版

首先再注释掉下方的t2线程相关代码后，程序是可以正常跑通的

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            boolean running = true;
            //在线程体中对线程的中断标志位进行判断，若线程中断，则不再执行
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd 'at' HH:mm:ss");
                    //
                    if (running) {
                        System.out.println("t1线程下载文件开始,时间：" + formatter.format(new Date(System.currentTimeMillis())));
                        Thread.sleep(3000);//执行花费3s
                        System.out.println("t1线程下载文件完成，时间: " + formatter.format(new Date(System.currentTimeMillis())));
                        running = false;//执行完成后设置标识为false
                    } else {
                        break;//已经执行过的线程结束自己的任务
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    //发生InterruptedException异常时，在catch中处理，中断线程
                    Thread.currentThread().interrupt();
                }
            }
        }, "t1");
        t1.start();

        //暂停20ms
//        TimeUnit.MILLISECONDS.sleep(20);
//        new Thread(() -> {
//            System.out.println("t2线程设置t1线程的中断标志为true");
//            t1.interrupt();//设置中断标志为true
//        }, "t2").start();
    }

结果：

其次，我们去打断线程，放开这些注释

可以看到运行结果只有线程的下载文件开始了，中途被打断。

那为甚么会出现异常呢？ 因为线程在sleep睡眠呢，你就把它打断了。。

调用目标线程的void interrupt()时

如果目标线程处于被阻塞状态（例如处于 sleep, wait, join 等状态），那么线程将立即退出被阻塞状态，并抛出一个InterruptedException 异常

如果目标线程处于正常活动状态，那么会将该线程的中断标志设置为 true。被设置中断标志的线程将继续正常运行，不受影响

---

volatile变量中断线程

通过一个volatile变量实现

public class InterruptDemo {
    static volatile boolean isStop = false;

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            while (true) {
                if (isStop) {
                    System.out.println(Thread.currentThread().getName() + "\t isStop被修改为true,t1线程结束");
                    break;
                }
                System.out.println("t1线程在循环中。。。");
            }

        }, "t1").start();

        //暂停20ms
        TimeUnit.MILLISECONDS.sleep(20);
        new Thread(() -> {
            System.out.println("t2线程开始执行");
            isStop = true;
        }, "t2").start();
    }
}

 t2把isStop改为true之后，t1觉察到了，就中断自己正在运行的线程，利用了volatile的可见性

---

AtomicBoolean中断线程

AtomicBoolean和volatile是一样的思想，只是用了不同的api

public class InterruptDemo {
    //    static volatile boolean isStop = false;
    static AtomicBoolean atomicBoolean = new AtomicBoolean(false);

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            while (true) {
                if (atomicBoolean.get()) {
                    System.out.println(Thread.currentThread().getName() + "\t atomicBoolean.get()被修改为true,t1线程结束");
                    break;
                }
                System.out.println("t1线程在循环中。。。");
            }

        }, "t1").start();

        //暂停20ms
        TimeUnit.MILLISECONDS.sleep(20);
        new Thread(() -> {
            System.out.println("t2线程开始执行");
            atomicBoolean.set(true);
        }, "t2").start();
    }
}