1.什么是守护线程？

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

按照官方这样的说法的话，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!");
	}
}

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

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

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

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