守护线程Daemon02

最新推荐文章于 2024-07-29 14:22:26 发布
最新推荐文章于 2024-07-29 14:22:26 发布
阅读量135 收藏
点赞数
分类专栏： Java多线程 文章标签： 多线程 java thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NoPainsNoGainsCSDN/article/details/116212414
版权

1 JVM线程分类

1.1 分类

  • 用户线程
  • 守护线程 Daemon Thread

1.2 守护线程tips

  • 两者唯一的区别只是jvm判断何时离开的问题(生命周期问题)
  • 当JVM中所有的线程都是守护线程的时候，JVM就可以退出了；如果还有一个或以上的非守护线程则不会退出
  • 守护线程是服务用户线程的，在start方法前调用setDaemon(true)把用户线程变成守护线程
  • 典型的守护线程便是java垃圾回收
  • jvm如果都是守护线程,jvm会退出(可以理解main线程执行结束 不再有用户线程)
  • 一个普通的应用程序java.exe代表操作系统启动了一个jvm进程，而一个jvm进程中至少有三个线程: main gc 线程，后两者都是守护线程

2 守护线程生命周期

  1. 只要JVM中尚存任何一个用户线程没有结束，守护线程就不会消亡且会工作
  2. 只有当最后一个用户线程消亡，守护线程会跟着消亡

3 作用

  • 为其他线程的运行提供服务 如GC

4 实验

4.1 实验一：父线程设置为守护线程，那么创建的子线程也是守护线程

  • 子线程

    @Slf4j
public class ChildThread implements Runnable{
    @Override
    public void run() {
        while (true){
            log.info("I am a child thread..");
            try{
                TimeUnit.MILLISECONDS.sleep(5000);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

  • 父线程改动

@Slf4j
public class DaemonMain {
    public static void main(String[] args) {
        Thread fatherThread = new Thread(){
            @Override
            public void run() {
                Thread childThread = new Thread(new ChildThread());
                childThread.setName("child Thread");
                //childThread.setDaemon(true);
                childThread.start();
                log.info("I am a main thread..");

            }
        };
        fatherThread.setDaemon(true);
        fatherThread.setName("Father Thread");
        fatherThread.start();
        log.info("over..");
    }
}

  • 输出

    22:27:27.801 [child Thread] INFO com.uestc.chapter04.ChildThread - I am a child thread..
22:27:27.804 [main] INFO com.uestc.chapter04.DaemonMain - over..
22:27:27.801 [Father Thread] INFO com.uestc.chapter04.DaemonMain - I am a main thread..

  • 详解

    • 父线程设置为守护线程，那么创建的子线程也是守护线程(尽管无线循环)

    • 所以一定要让主线程跑业务，子线程设置为守护线程（主线程不能设置守护线程）

4.2 实验二：被守护线程结束，守护线程也将结束(子线程为守护线程，父线程用户线程)

  • 子线程定义
@Slf4j
public class ChildThread implements Runnable{
    @Override
    public void run() {
        while (true){
            log.info("I am a child thread..");
            try{
                TimeUnit.MILLISECONDS.sleep(5000);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

  • 主线程定义

    //mainThread 是通过new thread形式创建
//childthread守护线程是通过接口形式创建
@Slf4j
public class DaemonMain {
    public static void main(String[] args) {
           Thread fatherThread = new Thread(){
            @Override
            public void run() {
                Thread childThread = new Thread(new ChildThread());
                childThread.setName("child Thread");
                childThread.setDaemon(true);
                childThread.start();
                log.info("I am a main thread..");

            }
        };
        //mainThread.setDaemon(true);
        fatherThread.setName("Father Thread");
        fatherThread.start();
        log.info("over..");
    }
}
/*
注意：该案例中是设立子线程为守护线程。如果该案例设置父线程为守护线程，子线程同样会结束，父为守护，子也为守护线程，即案列二
*/

  • 输出

    22:19:30.189 [main] INFO com.uestc.chapter04.DaemonMain - over..
22:19:30.192 [Father Thread] INFO com.uestc.chapter04.DaemonMain - I am a main thread..
22:19:30.191 [child Thread] INFO com.uestc.chapter04.ChildThread - I am a child thread..

  • 详解

    • 这里的main线程不是指代public static void main的这个线程，只是实验变量取名巧合了

    • 尽管你ChildThread守护线程(子线程)是个死循环，但是当它守护的Father Thread线程结束时(I am a main thread…执行完毕)，被守护的线程(child Thread)也跟着结束。

4.3 实验三： 整个jvm中只要有用户线程,则守护线程不会结束

  • 子线程定义:

    @Slf4j
public class ChildThread implements Runnable{
    @Override
    public void run() {
        while (true){
            log.info("I am a child thread..");
            try{
                TimeUnit.MILLISECONDS.sleep(5000);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

  • 主线程定义:

    Thread fatherThread = new Thread(new Runnable(){
            @Override
            public void run(){
               Thread childThread = new Thread(new ChildThread());
               childThread.setDaemon(true);
               childThread.setName("child Thread");
               childThread.start();
                log.info("I am a Father thread..");
            }
        });
        fatherThread.setName("Father Thread");
        fatherThread.start();
        Thread otherThread = new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){
                    log.info("I am a other thread");
                    try{
                        TimeUnit.MILLISECONDS.sleep(1000);
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                }
            }
        }){};
        otherThread.setName("otherThread Thread");
        otherThread.start();

  • 输出

    22:53:39.503 [Father Thread] INFO com.uestc.chapter04.DaemonMain - I am a Father thread..//输出一次 father线程执行结束
22:53:39.504 [child Thread] INFO com.uestc.chapter04.ChildThread - I am a child thread..
22:53:39.504 [otherThread Thread] INFO com.uestc.chapter04.DaemonMain - I am a other thread
22:53:40.513 [otherThread Thread] INFO com.uestc.chapter04.DaemonMain - I am a other thread
22:53:41.516 [otherThread Thread] INFO com.uestc.chapter04.DaemonMain - I am a other thread
22:53:42.516 [otherThread Thread] INFO com.uestc.chapter04.DaemonMain - I am a other thread
22:53:43.520 [otherThread Thread] INFO com.uestc.chapter04.DaemonMain - I am a other thread
22:53:44.510 [child Thread] INFO com.uestc.chapter04.ChildThread - I am a child thread..
22:53:44.523 [otherThread Thread] INFO com.uestc.chapter04.DaemonMain - I am a other thread
22:53:45.525 [otherThread Thread] INFO com.uestc.chapter04.DaemonMain - I am a other thread
22:53:46.529 [otherThread Thread] INFO com.uestc.chapter04.DaemonMain - I am a other thread
22:53:47.535 [otherThread Thread] INFO com.uestc.chapter04.DaemonMain - I am a other thread
22:53:48.537 [otherThread Thread] INFO com.uestc.chapter04.DaemonMain - I am a other thread
22:53:49.515 [child Thread] INFO com.uestc.chapter04.ChildThread - I am a child thread..
22:53:49.540 [otherThread Thread] INFO com.uestc.chapter04.DaemonMain - I am a other thread
22:53:50.541 [otherThread Thread] INFO com.uestc.chapter04.DaemonMain - I am a other thread
22:53:51.543 [otherThread Thread] INFO com.uestc.chapter04.DaemonMain - I am a other thread
22:53:52.548 [otherThread Thread] INFO com.uestc.chapter04.DaemonMain - I am a other thread
22:53:53.549 [otherThread Thread] INFO com.uestc.chapter04.DaemonMain - I am a other thread
22:53:54.517 [child Thread] INFO com.uestc.chapter04.ChildThread - I am a child thread..
22:53:54.549 [otherThread Thread] INFO com.uestc.chapter04.DaemonMain - I am a other thread
22:53:55.552 [otherThread Thread] INFO com.uestc.chapter04.DaemonMain - I am a other thread
22:53:56.553 [otherThread Thread] INFO com.uestc.chapter04.DaemonMain - I am a other thread
22:53:57.558 [otherThread Thread] INFO com.uestc.chapter04.DaemonMain - I am a other thread
22:53:58.562 [otherThread Thread] INFO com.uestc.chapter04.DaemonMain - I am a other thread
22:53:59.522 [child Thread] INFO com.uestc.chapter04.ChildThread - I am a child thread..
22:53:59.565 [otherThread Thread] INFO com.uestc.chapter04.DaemonMain - I am a other thread
22:54:00.570 [otherThread Thread] INFO com.uestc.chapter04.DaemonMain - I am a other thread
22:54:01.575 [otherThread Thread] INFO com.uestc.chapter04.DaemonMain - I am a other thread
22:54:02.579 [otherThread Thread] INFO com.uestc.chapter04.DaemonMain - I am a other thread
22:54:03.583 [otherThread Thread] INFO com.uestc.chapter04.DaemonMain - I am a other thread
  .
  .
  .

  • 解析

    • 尽管Father Thread线程结束，但是守护线程childThread监控到jvm中的用户线程还有otherThread(在while循环)，因此程序会一直打印不会退出。所以说守护线程守护的范围不仅仅是父子，而是整个jvm是否有用户线程

4.4 实验四 指定线程组 守护线程仍然守护

  • 子线程定义: 如上

  • 主线程

    Thread mainThread = new Thread(new Runnable(){
            @Override
            public void run(){
               Thread childThread = new Thread(new ChildThread());
               childThread.setDaemon(true);
               childThread.start();
               System.out.println("I'm main thread...");
            }
        });
        mainThread.start();
	
        ThreadGroup selfThreadGroup = new ThreadGroup("selfThreadGroup");
				//创建线程的时候指定线程所属的线程组-selfThreadGroup
        Thread otherThread = new Thread(selfThreadGroup,new Runnable() {
            @Override
            public void run() {
                while(true){
                    System.out.println("I am a other thread.");
                    try{
                        TimeUnit.MILLISECONDS.sleep(1000);
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                }
            }
        }){};
        otherThread.start();

  • 输出

    I am a other thread.
I'm main thread...
I am a child thread.
I am a other thread.
I am a child thread.
I am a other thread.
I am a child thread.
I am a other thread.
I am a child thread.

    详解

    • 尽管自定义创建了线程组，但是selfThreadGroup隶属于main的线程组的子(不允许创建孤立线程组)

      [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KXqMThim-1619536169062)(/Users/yuminghua/Library/Application Support/typora-user-images/image-20200507211111053.png)]

    • 尽管otherThread分配到了ThreadGroup中，但是也属于用户线程，所以也不会结束

4.5 实验五 守护线程采用线程池的方式开启（守护线程将变成用户线程）

  • 子线程： 如上

  • 主线程：

     Thread fatherThread = new Thread(new Runnable(){
            @Override
            public void run()
            {
                ExecutorService exec = Executors.newCachedThreadPool();
                Thread childThread = new Thread(new ChildThread());
                childThread.setDaemon(true);
                childThread.setName("childThread Thread");
                exec.execute(childThread);
                exec.shutdown();
                log.info("I am a Father thread..");
            }
        });
        fatherThread.setName("fatherThread Thread");
        fatherThread.start();
}

  • 输出

    23:07:18.642 [fatherThread Thread] INFO com.uestc.chapter04.DaemonMain - I am a Father thread..
23:07:18.642 [pool-1-thread-1] INFO com.uestc.chapter04.ChildThread - I am a child thread..
23:07:23.649 [pool-1-thread-1] INFO com.uestc.chapter04.ChildThread - I am a child thread..
23:07:28.651 [pool-1-thread-1] INFO com.uestc.chapter04.ChildThread - I am a child thread..
23:07:33.655 [pool-1-thread-1] INFO com.uestc.chapter04.ChildThread - I am a child thread..
23:07:38.659 [pool-1-thread-1] INFO com.uestc.chapter04.ChildThread - I am a child thread..
23:07:43.661 [pool-1-thread-1] INFO com.uestc.chapter04.ChildThread - I am a child thread..
23:07:48.666 [pool-1-thread-1] INFO com.uestc.chapter04.ChildThread - I am a child thread..
23:07:53.667 [pool-1-thread-1] INFO com.uestc.chapter04.ChildThread - I am a child thread..
23:07:58.667 [pool-1-thread-1] INFO com.uestc.chapter04.ChildThread - I am a child thread..
23:08:03.671 [pool-1-thread-1] INFO com.uestc.chapter04.ChildThread - I am a child thread..
23:08:08.675 [pool-1-thread-1] INFO com.uestc.chapter04.ChildThread - I am a child thread..
23:08:13.679 [pool-1-thread-1] INFO com.uestc.chapter04.ChildThread - I am a child thread..
.
.
.

  • 详解

    • 尽管被设置成了守护线程，但是以线程池的方式被开启，该守护线程会变成用户线程(优先级变成Thread.NORM_PRIORITY)

    • 线程池开启的线程都会把守护线程设置失效，且优先级调整成Normal

      [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wwIehNgl-1619536169064)(/Users/yuminghua/Library/Application Support/typora-user-images/image-20200507214224866.png)]

NoPainsNoGainscsdn
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
daemon 守护线程
zzh3864的博客
11-21 1064
Daemon线程是一种支持性线程，因为它主要用作程序中台调度以及支持性工作。这意味着，当一个Java虚拟机中不存在非Daemon线程的时候，Java虚拟机将会推出。可以通过调用Thread.setDaemon(true)将线程设为Daemon线程。（Daemon属性需要在线程启动之前设置）在Java虚拟机退出时finally块不一定会执行。 public class Test1 { static class DaemonRunner implements Runnable{ @Ove
java 线程 daemon_Java 守护线程Daemon
weixin_39611937的博客
02-12 250
Java的线程分为两种：User Thread(用户线程)、DaemonThread(守护线程)。只要当前JVM实例中尚存任何一个非守护线程没有结束，守护线程就全部工作；只有当最后一个非守护线程结束是，守护线程随着JVM一同结束工作，Daemon作用是为其他线程提供便利服务，守护线程最典型的应用就是GC(垃圾回收器)，他就是一个很称职的守护者。User和Daemon两者几乎没有区别，唯一的不同之处...
守护线程daemon
Massimo__JAVA的博客
09-17 166
守护线程daemon
linux daemon守护线程,守护线程(Daemon Thread)
weixin_35089515的博客
05-14 404
在Java中有两类线程：用户线程 (User Thread)、守护线程 (Daemon Thread)。所谓守护 线程，是指在程序运行的时候在后台提供一种通用服务的线程，比如垃圾回收线程就是一个很称职的守护者，并且这种线程并不属于程序中不可或缺的部分。因此，当所有的非守护线程结束时，程序也就终止了，同时会杀死进程中的所有守护线程。反过来说，只要任何非守护线程还在运行，程序就不会终止。用户线程和守护...
守护线程（Daemon线程）
张紫娃的博客
06-09 871
----------------------------------------------------------------------------读书笔记摘自 书名：Java并发编程的艺术 作者：方腾飞；终止，因此DaemonRunner立即终止，但是DaemonRunner中的。依靠finally块中的内容来确保执行关闭或清理资源的逻辑。Java虚拟机中的所有Daemon线程都需要。非Daemon线程时，虚拟机需要。将线程设置为Daemon线程。设置，不能在启动线程之后设置。调度以及支持性工作。
linux daemon守护线程,线程8--守护线程Daemon
weixin_36403587的博客
05-14 172
packagebook.thread;/***Daemon(守护)线程*Daemon线程区别一般线程之处是：*只有虚拟机中的用户线程(非Daimon线程)全部结束，Daemon线程就会立即结束,并且也不会调用finally里的语句。*daemon线程所产生的所有线程都是daemon的*/publicclassDaemon{staticclassMainThreadextendsThrea...
Java 守护线程 ( Daemon Thread )详解
Rcain_R的博客
05-12 1315
在Java多线程编程中，守护线程（Daemon Thread）是一种特殊类型的线程，其存在的目的是为了服务于用户线程（User Thread），提供辅助功能，如垃圾回收、监控或日志记录等。Java虚拟机（JVM）的正常运行并不依赖于守护线程的活动，当所有非守护线程（即用户线程）结束执行后，无论守护线程是否还在运行，JVM都会自动退出。这一特性使得守护线程非常适合执行那些不需要伴随程序整个生命周期的任务。
多线程—守护线程Daemon
you些话的博客
10-14 93
package thread.lzy.www; /** * 守护线程：是为用户线程服务的；JVM停止不用等待守护线程执行完毕 * 默认：用户线程jvm等待用户线程执行完才会停止 * @author Administration * */ public class DaemonTest { public static void main(String[] args) { God god=new God(); You you=new You(); Thread t=new Thread
java 线程 daemon_Java中的守护线程——daemon
weixin_30635747的博客
02-12 180
絮叨Java中有两类线程：User Thread(用户线程)、Daemon Thread(守护线程)定义：守护线程(aka：服务线程)，在没有用户线程可服务时会自动离开。优先级：守护线程的优先级较低，用于为系统中的其它对象和线程提供服务。用户线程即运行在前台的线程，而守护线程是运行在后台的线程。也就是说守护线程不依赖于终端，但是依赖于系统，与系统“同生共死”。守护线程作用是为其他前台线程的运行提供...
守护线程Daemon
arthur.dy.lee的专栏
09-28 926
守护线程在没有用户线程可服务时自动离开，在Java中比较特殊的线程是被称为守护（Daemon）线程的低级别线程。这个线程具有最低的优先级，用于为系统中的其它对象和线程提供服务。将一个用户线程设置为守护线程的方式是在线程对象创建之前调用线程对象的setDaemon方法。典型的守护线程例子是JVM中的系统资源自动回收线程，我们所熟悉的Java垃圾回收线程就是一个典型的守护线程，当我们的程序中不再有任何运行中的Thread，程序就不会再产生垃圾，垃圾回收器也就无事可做，所以当垃圾回收线程是Java虚拟机上仅剩的线
Java线程之守护线程（Daemon）用法实例
09-03
在Java中，线程分为两种类型：用户线程（User Thread）和守护线程（Daemon Thread）。这两种线程在大部分行为上是相同的，但它们在决定虚拟机何时退出时有显著差异。 用户线程是程序的主要部分，Java虚拟机（JVM）...
Python守护线程用法实例
09-21
在Python编程中，线程是并发执行任务的基本单位，而守护线程（Daemon Thread）是一种特殊类型的线程，它的主要特点是当所有非守护线程结束时，即使守护线程还在运行，Python解释器也会强制退出。了解并正确使用守护...
java daemon 守护线程实例
12-12
java daemon 程序，有助于理解守护线程的概念和使用
浅谈java的守护线程与非守护线程
08-29
在Java中，有两类线程：UserThread（用户线程）和Daemon Thread（守护线程）。守护线程的作用是为其他线程的运行提供服务，比如说GC线程。它们的本质上来说没有区别，唯一的区别之处就在虚拟机的离开：如果User ...
Java多线程守护线程
12-22
　在Java中有两类线程：User Thread(用户线程)、Daemon Thread(守护线程) 　作用 　Daemon的作用是为其他线程的运行提供便利服务，守护线程典型的应用是 GC (垃圾回收器)，它是一个很称职的守护者。 　区别 　...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 310
1.导入hutool的maven依赖。2.复制一下代码执行。
golang 接口
m0_70982551的博客
07-24 1101
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 146
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 589
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
Java守护线程详解：多线程基础与daemon应用
首先，守护线程（Daemon）在Java中指的是那些设计用于后台运行、为其他线程提供服务的线程。守护线程的主要特点是其run()方法是一个无限循环，它们的存在不是为了保持程序的生命周期，而是为了支持程序的正常运行。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值