Java的线程分为两种：User Thread(用户线程)、DaemonThread(守护线程)。

只要当前JVM实例中尚存任何一个非守护线程没有竣事，守护线程就全部事情；只有当最后一个非守护线程竣事是，守护线程跟着JVM一同竣事事情，Daemon浸染是为其他线程提供便利处事，守护线程最典范的应用就是GC(垃圾接纳器)，软件开发，他就是一个很称职的守护者。

User和Daemon两者险些没有区别，独一的差异之处就在于虚拟机的分开：假如 User Thread已经全部退出运行了，只剩下Daemon Thread存在了，虚拟机也就退出了。 因为没有了被守护者，Daemon也就没有事情可做了，也就没有继承运行措施的须要了。

首先看一个例子，主线程中成立一个守护线程，当主线程竣事时，守护线程也随着竣事。

java; gutter: true">package com.daemon;  
  
import java.util.concurrent.TimeUnit;  
  
public class DaemonThreadTest  
{  
    public static void main(String[] args)  
    {  
        Thread mainThread = new Thread(new Runnable(){  
            @Override  
            public void run()  
            {  
                Thread childThread = new Thread(new ClildThread());  
                childThread.setDaemon(true);  
                childThread.start();  
                System.out.println("I'm main thread...");  
            }  
        });  
        mainThread.start();  
    }  
}  
  
class ClildThread implements Runnable  
{  
    @Override  
    public void run()  
    {  
        while(true)  
        {  
            System.out.println("I'm child thread..");  
            try  
            {  
                TimeUnit.MILLISECONDS.sleep(1000);  
            }  
            catch (InterruptedException e)  
            {  
                e.printStackTrace();  
            }  
        }  
    }  
}

运行功效：

I'm child thread..  
I'm main thread...

假如不何止childThread为守护线程，当主线程竣事时，childThread还在继承运行，如下：

package com.daemon;  
  
import java.util.concurrent.TimeUnit;  
  
public class DaemonThreadTest  
{  
    public static void main(String[] args)  
    {  
        Thread mainThread = new Thread(new Runnable(){  
            @Override  
            public void run()  
            {  
                Thread childThread = new Thread(new ClildThread());  
                childThread.setDaemon(false);  
                childThread.start();  
                System.out.println("I'm main thread...");  
            }  
        });  
        mainThread.start();  
    }  
}  
  
class ClildThread implements Runnable  
{  
    @Override  
    public void run()  
    {  
        while(true)  
        {  
            System.out.println("I'm child thread..");  
            try  
            {  
                TimeUnit.MILLISECONDS.sleep(1000);  
            }  
            catch (InterruptedException e)  
            {  
                e.printStackTrace();  
            }  
        }  
    }  
}

运行功效：

I'm main thread...  
I'm child thread..  
I'm child thread..  
I'm child thread..  
I'm child thread..  
I'm child thread..（无限输出）

可以看到，当主线程竣事时，childThread长短守护线程，就会无限的执行。

守护线程有一个应用场景，就是当主线程竣事时，竣事其余的子线程（守护线程）自动封锁，劳务派遣管理系统，就免除了还要继承封锁子线程的贫苦。不外博主推荐，假如然有这种场景，照旧用间断的方法实现较量公道。

尚有增补一点，不是说当子线程是守护线程，主线程竣事，子线程就随着竣事，这里的前提条件是：当前jvm应用实例中没有用户线程继承执行，假如有其他用户线程继承执行，那么靠山线程不会间断，如下：

package com.daemon;  
  
import java.util.concurrent.TimeUnit;  
  
public class DaemonThreadTest  
{  
    public static void main(String[] args)  
    {  
        Thread mainThread = new Thread(new Runnable(){  
            @Override  
            public void run()  
            {  
                Thread childThread = new Thread(new ClildThread());  
                childThread.setDaemon(true);  
                childThread.start();  
                System.out.println("I'm main thread...");  
            }  
        });  
        mainThread.start();  
          
        Thread otherThread = new Thread(new Runnable(){  
            @Override  
            public void run()  
            {  
                while(true)  
                {  
                    System.out.println("I'm other user thread...");  
                    try  
                    {  
                        TimeUnit.MILLISECONDS.sleep(1000);  
                    }  
                    catch (InterruptedException e)  
                    {  
                        e.printStackTrace();  
                    }  
                }  
            }  
        });  
        otherThread.start();  
    }  
}  
  
class ClildThread implements Runnable  
{  
    @Override  
    public void run()  
    {  
        while(true)  
        {  
            System.out.println("I'm child thread..");  
            try  
            {  
                TimeUnit.MILLISECONDS.sleep(1000);  
            }  
            catch (InterruptedException e)  
            {  
                e.printStackTrace();  
            }  
        }  
    }  
}