JAVA 线程之守护线程Daemon Thread

最新推荐文章于 2024-08-21 21:23:20 发布
原创 最新推荐文章于 2024-08-21 21:23:20 发布 · 2.5k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #线程 #虚拟机 #deamon #守护线程

本文介绍了Java中的守护线程和用户线程的区别，守护线程在所有非守护线程结束后随虚拟机一同退出。内容包括如何将线程设置为守护线程、编写守护线程实例及使用jstack生成线程快照分析。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

在Java中有两类线程：

用户线程 (User Thread) 和 守护线程 (Daemon Thread)。

守护线程

  1. 是指在程序运行的时候在后台提供一种通用服务的线程,并不属于程序中不可或缺的部分

  2. 当所有的非守护线程结束时，程序也就终止了，同时会杀死进程中的所有守护线程

用户线程和守护线程区别：

唯一的不同之处就在于虚拟机的离开：如果用户线程已经全部退出运行了，只剩下守护线程存在了，虚拟机也就退出了。 因为没有了被守护者，守护线程也就没有工作可做了，也就没有继续运行程序的必要了。

将线程转换为守护线程

通过调用Thread对象的setDaemon(true)方法来实现。在使用守护线程时需要注意一下几点：

  1. 必须在start()方法之前设置

    thread.setDaemon(true)必须在thread.start()之前设置，否则会跑出一个IllegalThreadStateException异常。你不能把正在运行的常规线程设置为守护线程。

  2. 在Daemon线程中产生的新线程也是Daemon的

  3. 守护线程应该永远不去访问固有资源，如文件、数据库，因为它会在任何时候甚至在一个操作的中间发生中断

编写实例

  1. 编写DeamonThread类实现往文件中写入数据的功能
  2. 在主线程中将DeamonThread设置为守护线程 并且使用键盘输入模拟阻塞状态
  3. 当从键盘输入后从阻塞状态进入运行状态 主线程执行结束 守护线程也结束

DeamonThread :

package thread.demo3;

import java.io.*;

/**
 * 守护线程DeamonThread
 * Created by heqianqian on 2017/4/15.
 */
public class DeamonThread implements Runnable {
    private int count = 0;

    @Override
    public void run() {
        System.out.println("Deamon Thread Running....");
        File file = new File("Base/file/deamon/file.txt");
        OutputStream outputStream = null;
        try {
            outputStream = new FileOutputStream(file, true);
            while (count < 999) {
                outputStream.write(("word:"+count+"\r\n").getBytes());
                System.out.println(Thread.currentThread().getName()+" write word "+count++);
                Thread.sleep(1000);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if (outputStream!=null){
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println("Deamon Thread Over!");
    }
}

Main:

package thread.demo3;

import java.util.Scanner;

/**
 * Main
 * Created by heqianqian on 2017/4/15.
 */
public class Main {
    public static void main(String[] args) {
        System.out.println("Main Thread Running....");
        DeamonThread deamonThread = new DeamonThread();
        Thread thread = new Thread(deamonThread);
        thread.setDaemon(true);//设置为守护线程 且必须在start前调用
        thread.start();

        Scanner scanner = new Scanner(System.in);
        scanner.next();//模拟阻塞

        System.out.println("Main Thread Over!");
    }
}

运行结果：
这里写图片描述

file.txt文件内容：

这里写图片描述

使用jstack生成线程快照

运行程序后 打开任务管理器 找到当前程序的PID

这里写图片描述

打开CMD 输入 

jstack -l pid

可以看到快照结果

这里写图片描述

我们可以分析一下


C:\Users\heqianqian>jstack -l 10092
2017-04-15 09:54:03
Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.92-b14 mixed mode):

"RMI RenewClean-[localhost:52353]" #18 daemon prio=5 os_prio=0 tid=0x00000000173ac000 nid=0x239c in Object.wait() [0x0000000017b0f000]
   java.lang.Thread.State: TIMED_WAITING (on object monitor)
        at java.lang.Object.wait(Native Method)
        at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:143)
        - locked <0x00000000d01df4c0> (a java.lang.ref.ReferenceQueue$Lock)
        at sun.rmi.transport.DGCClient$EndpointEntry$RenewCleanThread.run(DGCClient.java:553)
        at java.lang.Thread.run(Thread.java:745)

   Locked ownable synchronizers:
        - None

"RMI Scheduler(0)" #17 daemon prio=5 os_prio=0 tid=0x00000000173a9000 nid=0x255c waiting on condition [0x0000000017a0e000]
   java.lang.Thread.State: TIMED_WAITING (parking)
        at sun.misc.Unsafe.park(Native Method)
        - parking to wait for  <0x00000000d02c2350> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
        at java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:215)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(AbstractQueuedSynchronizer.java:2078)
        at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(ScheduledThreadPoolExecutor.java:1093)
        at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(ScheduledThreadPoolExecutor.java:809)
        at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1067)
        at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1127)
        at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
        at java.lang.Thread.run(Thread.java:745)

   Locked ownable synchronizers:
        - None

"GC Daemon" #14 daemon prio=2 os_prio=-2 tid=0x000000001648b800 nid=0x2428 in Object.wait() [0x0000000016f0e000]
   java.lang.Thread.State: TIMED_WAITING (on object monitor)
        at java.lang.Object.wait(Native Method)
        at sun.misc.GC$Daemon.run(GC.java:117)
        - locked <0x00000000d02c2510> (a sun.misc.GC$LatencyLock)

   Locked ownable synchronizers:
        - None

"RMI Reaper" #13 prio=5 os_prio=0 tid=0x0000000016607000 nid=0x2268 in Object.wait() [0x0000000016e0f000]
   java.lang.Thread.State: WAITING (on object monitor)
        at java.lang.Object.wait(Native Method)
        - waiting on <0x00000000d01dfac0> (a java.lang.ref.ReferenceQueue$Lock)
        at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:143)
        - locked <0x00000000d01dfac0> (a java.lang.ref.ReferenceQueue$Lock)
        at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:164)
        at sun.rmi.transport.ObjectTable$Reaper.run(ObjectTable.java:351)
        at java.lang.Thread.run(Thread.java:745)

   Locked ownable synchronizers:
        - None

"RMI TCP Accept-0" #12 daemon prio=5 os_prio=0 tid=0x000000001655e000 nid=0x24a0 runnable [0x0000000016d0e000]
   java.lang.Thread.State: RUNNABLE
        at java.net.DualStackPlainSocketImpl.accept0(Native Method)
        at java.net.DualStackPlainSocketImpl.socketAccept(DualStackPlainSocketImpl.java:131)
        at java.net.AbstractPlainSocketImpl.accept(AbstractPlainSocketImpl.java:409)
        at java.net.PlainSocketImpl.accept(PlainSocketImpl.java:199)
        - locked <0x00000000d01df1b0> (a java.net.SocksSocketImpl)
        at java.net.ServerSocket.implAccept(ServerSocket.java:545)
        at java.net.ServerSocket.accept(ServerSocket.java:513)
        at sun.rmi.transport.tcp.TCPTransport$AcceptLoop.executeAcceptLoop(TCPTransport.java:400)
        at sun.rmi.transport.tcp.TCPTransport$AcceptLoop.run(TCPTransport.java:372)
        at java.lang.Thread.run(Thread.java:745)

   Locked ownable synchronizers:
        - None

"RMI TCP Accept-34855" #11 daemon prio=5 os_prio=0 tid=0x0000000016243800 nid=0x2338 runnable [0x0000000016c0f000]
   java.lang.Thread.State: RUNNABLE
        at java.net.DualStackPlainSocketImpl.accept0(Native Method)
        at java.net.DualStackPlainSocketImpl.socketAccept(DualStackPlainSocketImpl.java:131)
        at java.net.AbstractPlainSocketImpl.accept(AbstractPlainSocketImpl.java:409)
        at java.net.PlainSocketImpl.accept(PlainSocketImpl.java:199)
        - locked <0x00000000d0211318> (a java.net.SocksSocketImpl)
        at java.net.ServerSocket.implAccept(ServerSocket.java:545)
        at java.net.ServerSocket.accept(ServerSocket.java:513)
        at sun.rmi.transport.tcp.TCPTransport$AcceptLoop.executeAcceptLoop(TCPTransport.java:400)
        at sun.rmi.transport.tcp.TCPTransport$AcceptLoop.run(TCPTransport.java:372)
        at java.lang.Thread.run(Thread.java:745)

   Locked ownable synchronizers:
        - None

"Service Thread" #9 daemon prio=9 os_prio=0 tid=0x0000000016296000 nid=0x284c runnable [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

   Locked ownable synchronizers:
        - None

"C1 CompilerThread2" #8 daemon prio=9 os_prio=2 tid=0x000000001621b000 nid=0x27c0 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

   Locked ownable synchronizers:
        - None

"C2 CompilerThread1" #7 daemon prio=9 os_prio=2 tid=0x0000000016215800 nid=0x286c waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

   Locked ownable synchronizers:
        - None

"C2 CompilerThread0" #6 daemon prio=9 os_prio=2 tid=0x0000000014c8d000 nid=0x26f0 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

   Locked ownable synchronizers:
        - None

"Attach Listener" #5 daemon prio=5 os_prio=2 tid=0x0000000014c8b800 nid=0x27a0 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

   Locked ownable synchronizers:
        - None

"Signal Dispatcher" #4 daemon prio=9 os_prio=2 tid=0x0000000014c40000 nid=0x2780 runnable [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

   Locked ownable synchronizers:
        - None

"Finalizer" #3 daemon prio=8 os_prio=1 tid=0x0000000002ebd000 nid=0x279c in Object.wait() [0x0000000015faf000]
   java.lang.Thread.State: WAITING (on object monitor)
        at java.lang.Object.wait(Native Method)
        at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:143)
        - locked <0x00000000d02c32b0> (a java.lang.ref.ReferenceQueue$Lock)
        at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:164)
        at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:209)

   Locked ownable synchronizers:
        - None

"Reference Handler" #2 daemon prio=10 os_prio=2 tid=0x0000000002eb2000 nid=0x26e0 in Object.wait() [0x0000000015eaf000]
   java.lang.Thread.State: WAITING (on object monitor)
        at java.lang.Object.wait(Native Method)
        at java.lang.Object.wait(Object.java:502)
        at java.lang.ref.Reference.tryHandlePending(Reference.java:191)
        - locked <0x00000000d02ea1c8> (a java.lang.ref.Reference$Lock)
        at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:153)

   Locked ownable synchronizers:
        - None

"main" #1 prio=5 os_prio=0 tid=0x0000000002dc2800 nid=0x2844 in Object.wait() [0x00000000029ff000]
   java.lang.Thread.State: TIMED_WAITING (on object monitor)
        at java.lang.Object.wait(Native Method)
        at com.intellij.execution.rmi.RemoteServer.start(RemoteServer.java:86)
        - locked <0x00000000d02c3350> (a java.lang.Object)
        at org.jetbrains.idea.maven.server.RemoteMavenServer.main(RemoteMavenServer.java:22)

   Locked ownable synchronizers:
        - None

"VM Thread" os_prio=2 tid=0x0000000014bf7000 nid=0x2794 runnable

"GC task thread#0 (ParallelGC)" os_prio=0 tid=0x0000000002dd8800 nid=0x2878 runnable

"GC task thread#1 (ParallelGC)" os_prio=0 tid=0x0000000002dda000 nid=0x2804 runnable

"GC task thread#2 (ParallelGC)" os_prio=0 tid=0x0000000002ddb800 nid=0x1d9c runnable

"GC task thread#3 (ParallelGC)" os_prio=0 tid=0x0000000002ddd000 nid=0x25e8 runnable

"VM Periodic Task Thread" os_prio=2 tid=0x00000000162dc000 nid=0x27c4 waiting on condition

JNI global references: 236


C:\Users\heqianqian>
  1. Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.92-b14 mixed mode)
    线程块运行在java虚拟机hotspot上 是64位的服务端
  2. 接下来是一些java自带的守护进程
    比如GC线程

这里写图片描述

可以看到是deamon线程 优先级是2 当前状态为有时间的等待状态

Locked ownable synchronizers 是否处于同步块中

最后显示的是我们的主线程

这里写图片描述

可以看到主线程并不是一个守护线程 并且处于等待状态 原因是我们的键盘输入阻塞了主线程

jstack使用参数

这里写图片描述

参考文章：

http://www.cnblogs.com/diyingyun/archive/2011/12/25/2300998.html

http://www.cnblogs.com/super-d2/p/3348183.html

Java 守护线程 ( Daemon Thread )详解
Rcain_R的博客
05-12 3685
在Java多线程编程中，守护线程（Daemon Thread）是一种特殊类型的线程，其存在的目的是为了服务于用户线程（User Thread），提供辅助功能，如垃圾回收、监控或日志记录等。Java虚拟机（JVM）的正常运行并不依赖于守护线程的活动，当所有非守护线程（即用户线程）结束执行后，无论守护线程是否还在运行，JVM都会自动退出。这一特性使得守护线程非常适合执行那些不需要伴随程序整个生命周期的任务。
daemon 守护线程
zzh3864的博客
11-21 1121
Daemon线程是一种支持性线程，因为它主要用作程序中台调度以及支持性工作。这意味着，当一个Java虚拟机中不存在非Daemon线程的时候，Java虚拟机将会推出。可以通过调用Thread.setDaemon(true)将线程设为Daemon线程。（Daemon属性需要在线程启动之前设置）在Java虚拟机退出时finally块不一定会执行。 public class Test1 { static class DaemonRunner implements Runnable{ @Ove
JAVA并发编程——守护线程(Daemon Thread)
你有什么可以拽？
10-07 1989
在Java中有两类线程：用户线程 (User Thread)、守护线程 (Daemon Thread)。 所谓守护 线程，是指在程序运行的时候在后台提供一种通用服务的线程，比如垃圾回收线程就是一个很称职的守护者，并且这种线程并不属于程序中不可或缺的部分。因此，当所有的非守护线程
Daemon守护线程
LiuXiaoXueer的博客
08-27 171
守护线程是程序运行时在后台提供服务的线程 1、设置Daemon属性：Thread.setDaemon(true) 在启动线程之前设置 2、当所有非守护线程结束时，程序终止，所有守护线程需要立即停止 3、main()属于非守护线程 4、程序终止时，守护线程中的finally块并一定会执行 public class Daemon { public static void main(String[] args) { Thread thread = new Thread(new DaemonRunner()
Java线程之守护线程（Daemon）用法实例
09-03
在Java中，线程分为两种类型：用户线程（User Thread）和守护线程（Daemon Thread）。这两种线程在大部分行为上是相同的，但它们在决定虚拟机何时退出时有显著差异。 用户线程是程序的主要部分，Java虚拟机（JVM）...
java守护线程（Daemon Thread）和用户线程（User Thread）
最新发布
a1241436267的博客
08-21 387
只要有一个用户线程还在运行，JVM就不会终止，除非显式地调用System.exit()方法来退出。用户线程通常是应用程序中直接创建的线程，用于执行应用程序的主要任务。所有的用户线程都结束时，无论守护线程是否仍在运行，JVM都会退出。作为辅助角色存在，不影响程序的生命周期，主要用于提供支持和服务。是程序的主要组成部分，决定了程序的生命周期。执行业务逻辑，如计算任务、网络请求等。线程执行之前调用setDeamon()我们平时所创建的都是用户线程。执行一些辅助性的任务，比如。为用户线程提供服务。
详解Java线程-守护线程与用户线程
08-26
Java中的线程可以分为守护线程(DaemonThread)和用户线程(UserThread)两类。守护线程和用户线程的唯一区别是它们对虚拟机的退出(程序的终止)的影响。 当JVM中只有守护线程时，虚拟机会退出，程序终止；而当JVM中至少...
【java 多线程】守护线程与非守护线程的详解
08-26
Java 中有两类线程：User Thread（用户线程）和 Daemon Thread（守护线程）。用户线程即运行在前台的线程，而守护线程是运行在后台的线程。守护线程的作用是为其他前台线程的运行提供便利服务，而且仅在普通、非守护...
守护(daemon)线程
weixin_52385232的博客
07-07 267
守护(daemon)线程
守护（daemon）线程
UohzZ的博客
02-11 231
守护线程Daemon、代码
一文秒懂 Java 守护线程 ( Daemon Thread )
smart_an的专栏
02-07 1245
作者简介：大家好，我是哥，前中兴通讯、美团架构师，现某互联网公司联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬学习必须往深处挖，挖的越深，基础越扎实！在这篇简短的文章中，我们将讲解下 Java 中的守护线程，看看它们可以做什么。我们还将解释守护线程和用户线程之间的区别。
Daemon Thread
saraspeer的专栏
04-18 4037
1.所谓守护线程就是运行在程序后台的线程，程序的主线程Main（比方java程序一开始启动时创建的那个线程）不会是守护线程.2.Daemon thread在Java里面的定义是，如果虚拟机中只有Daemon thread 在运行，则虚拟机退出。    虚拟机中可能会同时有很多个线程在运行，只有当所有的非守护线程都结束的时候，虚拟机的进程才会结束，不管在运行的线程是不是main()线程。3.
Java多线程-daemon守护线程
qq_42218187的博客
12-22 521
案例一： /** * 什么是守护线程？ * 当 JVM 中不存在任何一个正在运行的非守护线程时，则 JVM 进程即会退出。 * 如果 JVM 中没有一个正在运行的非守护线程，这个时候，JVM 会退出。换句话说，守护线程拥有自动结束自己生命周期的特性，而非守护线程不具备这个特点。 * * 应用场景： * JVM 中的垃圾回收线程就是典型的守护线程，如果说不具备该特性，会发生什么呢？ * 当 JVM 要退出时，由于垃圾回收线程还在运行着，导致程序无法退出，这就很尴尬了！！！由此可见，守护线程的重要
thread daemon
illegalplayer1的博客
09-05 395
package thread;public class DaemonThread extends Thread{DaemonThread(String name){ super(name); } @Override public void run() { for(int i=1;i<=100;i++){ System.out.println("更新包下载中"+i+"%
守护线程(Daemon Thread)
z69183787的专栏
04-07 913
在Java中有两类线程：用户线程 (User Thread)、守护线程 (Daemon Thread)。 所谓守护 线程，是指在程序运行的时候在后台提供一种通用服务的线程，比如垃圾回收线程就是一个很称职的守护者，并且这种线程并不属于程序中不可或缺的部分。因此，当所有的非守护线程结束时，程序也就终止了，同时会杀死进程中的所有守护线程。反过来说，只要任何非守护线程还在运行，程序就不会终止。 用户...
ThreadDaemon(线程守护)
DingX_001的博客
07-12 669
线程守护 ：xx.setDaemon(true) 主线程结束子线程也跟着结束啦
java中的daemon thread
m0_66876551的博客
04-29 1380
java中的daemon thread java中有两种类型的thread，user threads 和 daemon threads。 User threads是高优先级的thread，JVM将会等待所有的User Threads运行完毕之后才会结束运行。 daemon threads是低优先级的thread，它的作用是为User Thread提供服务。 因为daemon threads的低优先级，并且仅为user thread提供服务，所以当所有的user thread都结束之后，JVM会自动退出，不管
python thread daemon
我是张先生
06-16 5520
Python解释器直到所有线程都终止前仍保持运行。对于需要长时间运行的线程或者需要一直运行的后台任务，你应当考虑使用后台线程。 例如： t = Thread(target=countdown, args=(10,), daemon=True) t.start() import threading import time def read(): i = 0 while True: print('求你了，快退出吧') i += 1 time.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值