今天看书的时候，看到一个名词，守护线程，迫不及待的想要了解一下，有了以下一系列的思考和总结。

1.什么是守护线程？

首先看一下，Java官方对于守护线程的注释是怎么样的？

守护进程（Daemon）是运行在后台的一种特殊进程。它独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。守护进程是一种很有用的进程。

按照官方这样的说法的话，JVM GC不就是一个天生的守护线程吗？只要一个程序启动之后，独立与控制终端，可以独立运行，而且一直在后台等待周期性的触发GC，回收内存。问题随之而来

• 主线程是守护线程吗？--不是，和概念中的独立于控制终端明显不匹配，而且周期性的执行某种任务
• Java GC是内置的守护线程，那我们可以自己写一个吗？--可以，通过thread.setDaemon(true)
• 守护线程是随着主线程退出而退出的吗？
  带着上面的问题，我们写几段代码验证一下
  开启一个自定义线程，1s打印一次，main线程运行完成之后，打印退出，那此时JVM可以正常退出吗？

public class Main {

    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {

            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("Current Thread is running!");
                }
            }
        });
        thread.start();

        System.out.println("Main Thread exit!");
    }
}

image.png

可以看到此时主线程已经退出，但是子线程依然在运行，JVM无法正常退出，验证了JVM官方一句话

The Java Virtual Machine exits when the only threads running are all daemon threads.
当 JVM 中不存在任何一个正在运行的非守护线程时，则 JVM 进程即会退出。

接下来我们把这个线程改为守护线程，再次运行一下

image.png

经过上面的代码验证，我们小结一下：
守护线程相比于普通线程来说，更加的安全，它可以自己控制关闭，在程序退出的时候，关闭自己。即使你在你的守护线程里面写了死循环，也没有关系。通常来说，守护线程经常被用来执行一些后台任务，但是呢，你又希望在程序退出时，或者说 JVM 退出时，线程能够自动关闭，此时，守护线程是你的首选。

2.普通线程最好的退出方式

上面了解了守护线程的退出方式，突然想到，自己之前代码中更多编写的肯定是普通线程，那么自己之前是怎么退出普通线程的，这里也稍微总结一下代码。

public class Main {
    public static class WorkTask extends Thread {
        boolean isExit = false;
        @Override
        public void run() {
            super.run();
            while (!isExit) {
                System.out.println("Current Thread is running!");
            }
        }

        public void shutDown() {
            if (isAlive()) {
                interrupt();
                isExit = true;
            }
        }
    }
    public static void main(String[] args) {
        WorkTask task = new WorkTask();
        task.start();

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        task.shutDown();
        task = null;
        System.out.println("Main Thread exit!");
    }
}

只到这里了吗，no no no...
大家发现上面写的例子是，现场有运行任务，但是，如果我们也知道，线程有那么多状态，interrupt真的可以统一解决吗？答案：不是。
我们把上面的代码改一下，在线程内部run里面，有wait、sleep操作

public class Main {
    public static class WorkTask extends Thread {
        boolean isExit = false;
        @Override
        public void run() {
            super.run();
            while (!isExit) {
                try {
                                        //add this
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println("Current Thread is running!");
            }
        }

        public void shutDown() {
            if (isAlive()) {
                interrupt();
                isExit = true;
            }
        }
    }
    public static void main(String[] args) {
        WorkTask task = new WorkTask();
        task.start();

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        task.shutDown();
        task = null;
        System.out.println("Main Thread exit!");
    }
}

此时运行代码，发现程序有异常抛出。

Current Thread is running!
Current Thread is running!
Main Thread exit!
java.lang.InterruptedException: sleep interrupted
Current Thread is running!
    at java.base/java.lang.Thread.sleep(Native Method)
    at Main$WorkTask.run(Main.java:9)

这里我们就能知道，interrupt的实质作用了：
interrupt()的作用是中断本线程。如果本线程是处于阻塞状态：调用线程的wait() join() sleep(long)也会让它进入阻塞状态。若线程在阻塞状态时，调用了它的interrupt()方法，那么它的“中断状态”会被清除并且会收到一个InterruptedException异常，线程的中断标记会被设置为true，并且它会立即从选择操作中返回。

但是还有一种情况，是interrupt处理不了的，大家记得线程还有一种状态是死锁吗？

public class Main {
    public static class WorkTask extends Thread {
        boolean isExit = false;
        @Override
        public void run() {
            super.run();
            while (!isExit) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println("Current Thread is running!");
            }
        }

        public void shutDown() {
            if (isAlive()) {
                interrupt();
                isExit = true;
            }
        }
    }

    public static void main(String[] args) {
        Object lock1 = new Object();
        Object lock2 = new Object();

        Thread thread1 = new Thread(new Runnable() {

            @Override
            public void run() {
                synchronized (lock1) {
                    System.out.println(
                            Thread.currentThread().getId() + "get lock1");
                    synchronized (lock2) {
                        try {
                            Thread.sleep(200);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        System.out.println(
                                Thread.currentThread().getId() + "get lock2");
                    }
                }
            }
        });
        thread1.start();

        Thread thread2 = new Thread(new Runnable() {

            @Override
            public void run() {
                synchronized (lock2) {
                    System.out.println(
                            Thread.currentThread().getId() + "get lock2");
                    synchronized (lock1) {
                        System.out.println(
                                Thread.currentThread().getId() + "get lock1");
                    }
                }
            }
        });
        thread2.start();

        thread1.interrupt();
        System.out.println("Main Thread exit!");
    }
}

上面的列子，写了一个死锁（模拟死锁四个条件中的一个，形成了死锁环），此时调用interrupt发现结果如下：

image.png

大家发现，两个线程均无法正常结束，所以interrupt无法终止这种情况。

小结
interrupt可以中断处理，运行状态和阻塞状态，但是无法处理死锁状态