说说用户线程和守护线程

超、凢脫俗 2024-04-08 11:34 88阅读 0赞

### 用户线程和守护线程了解吗？ ###

### 什么是用户线程和守护线程？ ###

守护线程是一种特殊的线程，在后台默默地完成一些系统性的服务，比如 **垃圾回收线程** 、 **JIT线程** 都是 **守护线程** 。与之对应的是 **用户线程** ，用户线程可以理解为是系统的工作线程，它会完成这个程序需要完成的业务操作。

### 如何手动设置线程为守护线程？ ###

java 中的线程分为两种：守护线程（Daemon）和用户线程（User）。任何线程都可以设置为守护线程和用户线程，通过方法 setDaemon() 即可实现。

// 接口方法
    void setDaemon(boolean on)	// 将此线程标记为用户线程，true 则把该线程设置为守护线程，反之则为用户线程
        
    boolean	isDaemon()		// 判断这个线程是否是守护线程，返回true表示守护线程，否则为用户线程

注意点：

*  当程序中所有的用户线程执行完毕之后，不管守护线程是否结束，系统都会自动退出；
 *  java线程分为用户线程和守护线程，线程的 daemon 属性为 true 表示是守护线程，false 表示是用户线程；
 *  设置守护线程： `t1.setDaemon(true)` ，该语句要放在 `t1.start()` 方法执行之前，如果放在后面，会报 `IllegalThreadStateException` 异常，不起作用；

:chestnut: 1：

public class Demo {
        /**
        	验证：当程序中所有的用户线程执行完毕之后，不管守护线程是否结束，系统都会自动退出
        */
        
        static class T1 extends Thread {
            public T1(String name) {
                super(name);
            }
            @Override
            public void run() {
                System.out.println(this.getName() + "开始执行," + (this.isDaemon() ? "我是守护线程" : "我是用户线程"));
                while (true) ;	// 死循环
            }
        }
        public static void main(String[] args) {
            T1 t1 = new T1("t1");
            t1.setDaemon(true);		// 放在 t1.start() 方法执行之前，设为守护线程
            t1.start();
            System.out.println("主线程结束");
        }
    }
    
    //------------------ 运行结果
    主线程结束
    t1开始执行,我是守护线程		（程序正常结束）

:chestnut: 2：

/**
    	验证：设置守护线程，需要在start()方法之前进行
    */
    public class Demo1 {
        
        static void main(String[] args) {
            Thread t1 = new Thread() {
                @Override
                public void run() {
                    try {
                        TimeUnit.SECONDS.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
            t1.start();
            t1.setDaemon(true);
        }
    }
    
    //------------------ 运行结果
    Exception in thread "main" java.lang.IllegalThreadStateException
    	at java.lang.Thread.setDaemon(Thread.java:1359)

### 源码看看 ###

查看 Thread 的源码，发现 布尔型变量 daemon 是Thread类中的一个成员变量，默认值为 false。

/*  Thread.java  */
    public class Thread implements Runnable {
     	......
    	// 布尔型变量 daemon 是Thread类中的一个成员变量，默认值为 false
        private boolean daemon = false;
    }

查看线程的 `init` 方法（init 方法在创建线程时会执行，该方法作用在 `Thread` 构造器内部），可以看出 dameon 的默认值为父线程的daemon。也就是说，父线程如果为用户线程，子线程默认也是用户现场；父线程如果是守护线程，子线程默认也是守护线程。

父线程就是创建当前线程的那个线程，比如我们经常在main函数中 new 一个 t1 线程，那 main 线程是 t1 线程的父线程，t1 是子线程。

/*  Thread.java  */
    private void init(ThreadGroup g, Runnable target, String name,.......){
        ......
        Thread parent = currentThread();
    	this.daemon = parent.isDaemon();
        ......
    }

:chestnut: 1：

public class Demo2 {
        
        static class T extends Thread {
            public T(String name) {
                super(name);
            }
            @Override
            public void run() {
                System.out.println(this.getName() + ".daemon:" + this.isDaemon());
            }
        }
        
        public static void main(String[] args) throws InterruptedException {
            // 打印 main 线程的状态
            System.out.println(Thread.currentThread().getName() + ".daemon:" + Thread.currentThread().isDaemon());
            // main 线程中创建了 t1 线程
            T t1 = new T("t1");
            t1.start();
            
            Thread t2 = new Thread() {
                @Override
                public void run() {
                    System.out.println(this.getName() + ".daemon:" + this.isDaemon());
                    // t2 内创建了 t3 线程
                    T t3 = new T("t3");
                    t3.start();
                }
            };
            t2.setName("t2");
            t2.setDaemon(true);		// 手动设置 t2 为守护线程
            t2.start();
            TimeUnit.SECONDS.sleep(2);
        }
    }
    
    //------------------ 运行结果
    main.daemon:false	
    t1.daemon:false
    t2.daemon:true
    t3.daemon:true

### 总结 ###

1.  java 中的线程分为两种：守护线程（Daemon）和用户线程（User）；
2.  当程序中所有的用户线程执行完毕之后，不管守护线程是否结束，系统都会自动退出；
3.  任何线程都可以设置为守护线程和用户线程，通过方法 `setDaemon(boolean on)` 即可实现。此外， `setDaemon(boolean on)` 方法必须在线程的start()方法之前调用，在后面调用会报异常；
4.  线程的 `daemon` 默认值和其父线程（创建它的线程）一样；
5.  Thread Dump 打印出来的线程信息，含有 daemon 字样的线程即为守护进程，常见的守护线程有 服务守护进程、编译守护进程、windows 下的监听 Ctrl+break 的守护进程、Finalizer 守护进程、引用处理守护进程、GC 守护进程。