Java语言中的守护线程（Daemon Thread）

持续创作，加速成长！这是我参与「掘金日新计划 · 10 月更文挑战」的第19天，点击查看活动详情

守护线程

在Java语言中有两类线程：用户线程和守护线程。我们通俗的讲，任意一个守护线程都是整个JVM中所有线程的"大管家"；只要当前Java虚拟机中还有任意一个非守护线程没有结束，它们的守护线程就不能结束，要持续工作；只有当最后一个非守护线程结束时，守护线程才随着Java虚拟机一起结束工作。

其作用就是为其他线程的运行提供服务，就像是一个护道者，保证其他线程的顺利运行

用户线程设为守护线程

我们将用户线程设为守护线程的办法就是Thread类的setDaemon(true)方法。假设我们创建一个线程t，然后我们将它设为守护线程，这时我们就应该注意： 1. 守护线程应该永远不会去访问系统资源(比如数据库、文件等)，因为它会在任何时候甚至正在进行某种操作时发生中断。 2. 守护线程在运行期间定义并由守护线程创建的线程，都自然而然地是守护线程 3. t.setDaemon(true)必须在t.start()之前调用，否则会发生IllegalThreadStateException异常。原因是不能把正在运行的常规线程设为守护线程

代码示例
SubThead类：

```java public class SubThread extends Thread{ int u1,v1; int result=0; //构造方法 public SubThread(String name){ super(name); //随机产生0~100以内的整数 u1=(int)(Math.random()100); v1=(int)(Math.random()100);

}

    @Override
    public void run() {
        //如果没有最大公约数，就进行计算
        if (result==0){
            result=this.getMaxCommonDivisor();
            System.out.println ("运行····"+this);
            while (true){
                Thread.yield ();  //暂停当前线程，执行其他线程
            }
        }
    }
    //得到最大公约数
    public int getMaxCommonDivisor() {
        int u=u1,v=v1,r=u;
        while (r!=0){
            u=v;
            v=r;
            r=u%v;
        }
    return v;
    }

    @Override
    public String toString() {
        String msg;
        msg="threadName:"+this.getName ()+", ahead(优先级)："+getPriority ();
        String msg1=this.isDaemon ()?"，守护线程:" :"用户线程";
        msg=msg+msg1+".["+u1+","+v1+"的最大公约数是"+result+"]";
        return msg;
    }
}

``` 注意： public int getMaxCommonDivisor():该方法是为了得到u1、v1的最大公约数

DaemonThread类

```java import com.alibaba.druid.support.json.JSONUtils;

import java.sql.SQLOutput;

public class DaemonThread extends Thread{ public DaemonThread(String name){ super(name); } public void print(){ String msg; msg="线程："+getName ()+";优先级"+getPriority ()+",是守护线程"+isDaemon (); System.out.println (msg); return; }

@Override
public String toString() {
    String msg;
    msg = "threadName:" + this.getName () + ", ahead(优先级)：" + getPriority ();
    String msg1 = this.isDaemon () ? "，守护线程:" : "用户线程";
    msg="线程名："+this.getName ()+",优先级"+this.getPriority ()+msg1;
    return msg;
}

@Override
public void run() {
    int i;
    System.out.println ("运行---"+this);
    //定义子线程
    SubThred subThred[]=new SubThred[5];
    //创建子线程
    for (int i = 0; i < 5; i++) {
        subThred[i]=new SubThread("子线程："+i);
    }
    for (int i = 0; i < 5; i++) {
        subThred[i].start();//启动子线程
    }
}

} ```

DaemonTest类

```java

import java.util.concurrent.TimeUnit;

public class DaemonTest{ //输出线程信息 public static void print(Thread t) { String msg; String msg1 = this.isDaemon () ? "，守护线程:" : "用户线程"; msg="线程名："+this.getName ()+",优先级"+this.getPriority ()+msg1; System.out.println (msg); return ; }

public static void main(String[] args) throws InterruptedException{
    //得到当前主线程
    Thread t = Thread.currentThread ();
    //输出当前主线程
    print ( t );
    DaemonThread daemonThread =new DaemonThread("守护线程A" );
    daemonThread(true);//将线程设为守护线程
    daemonThread.start();
    //主线程睡眠
    TimeUnit.SECONDS.sleep ( 5 );
    //输出当前主线程
    print ( t );
}

} ``` 注：在运行DaemonTest类的main方法过程中，此时main线程获得了系统资源处于运行状态，然后创建了线程A，然后将A设为了守护线程并启动了线程A，线程A创建了守护线程A1、A2、A3、A4。然后，main线程睡眠了5秒，此时线程A创建的若干个子线程被唤醒，分别进入运行状态。在子线程的运行过程中随机产生了两个随机数的最大公约数，接着进入暂停状态。main线程睡眠后又得到了系统资源，代码运行结束，main线程生命结束，子线程也被系统回收·····