【java 多线程】守护线程与非守护线程的详解

更新时间：2019年04月28日 15:09:37 作者：紫仙空灵

这篇文章主要介绍了java守护线程与非守护线程，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧

Java中有两类线程：User Thread(用户线程)、Daemon Thread(守护线程)

用户线程即运行在前台的线程，而守护线程是运行在后台的线程。守护线程作用是为其他前台线程的运行提供便利服务，而且仅在普通、非守护线程仍然运行时才需要，比如垃圾回收线程就是一个守护线程。当VM检测仅剩一个守护线程，而用户线程都已经退出运行时，VM就会退出，因为没有如果没有了被守护这，也就没有继续运行程序的必要了。如果有非守护线程仍然存活，VM就不会退出。

守护线程并非只有虚拟机内部提供，用户在编写程序时也可以自己设置守护线程。用户可以用Thread的setDaemon（true）方法设置当前线程为守护线程。

虽然守护线程可能非常有用，但必须小心确保其他所有非守护线程消亡时，不会由于它的终止而产生任何危害。因为你不可能知道在所有的用户线程退出运行前，守护线程是否已经完成了预期的服务任务。一旦所有的用户线程退出了，虚拟机也就退出运行了。因此，不要在守护线程中执行业务逻辑操作（比如对数据的读写等）。、

另外有几点需要注意：

1、setDaemon(true)必须在调用线程的start（）方法之前设置，否则会抛出IllegalThreadStateException异常。
2、在守护线程中产生的新线程也是守护线程。
3、不要认为所有的应用都可以分配给守护线程来进行服务，比如读写操作或者计算逻辑。

Timer代码示例：

package day003;

import java.util.Date;
import java.util.TimerTask;

/**
*
* 项目名称：JavaThread
* 类名称：MyTask
* 类描述：
* 创建人：liuc
* 创建时间：2018年3月19日 下午3:05:28
* 修改人：liuc
* 修改时间：2018年3月19日 下午3:05:28
* 修改备注：
* @version
*
*/
public class MyTask extends TimerTask{

 /**
 * (non-Javadoc)
 * @see java.util.TimerTask#run()
 */
 public void run() {
   System.out.println("任务执行了，时间为："+new Date());
 }
}
-----------------------------------------------------------------------------------
package day003;

import java.util.Calendar;
import java.util.Date;
import java.util.Timer;

/**
*
* 项目名称：JavaThread
* 类名称：TimerTaskRun
* 类描述：
* 创建人：liuc
* 创建时间：2018年3月19日 下午3:08:01
* 修改人：liuc
* 修改时间：2018年3月19日 下午3:08:01
* 修改备注：
* @version
*
*/
public class TimerTaskRun {
 public static void main(String[] args) {
  System.out.println("系统当前时间："+new Date());
  Calendar calendar = Calendar.getInstance();
  calendar.add(Calendar.SECOND, 10);
  Date date = calendar.getTime();
  MyTask task = new MyTask();
  Timer timer = new Timer();
  timer.schedule(task, date);
 }
}

运行结果：

系统当前时间：Mon Mar 19 15:11:47 CST 2018
任务执行了，时间为：Mon Mar 19 15:11:57 CST 2018

任务虽然运行完了，但进程还未销毁，呈红色状态，为什么会出现这种情况呢？

可以看一下Timer的源码

/**
  * Creates a new timer. The associated thread does <i>not</i>
  * {@linkplain Thread#setDaemon run as a daemon}.
  */
 public Timer() {
  this("Timer-" + serialNumber());
 }


 /**
  * Creates a new timer whose associated thread has the specified name.
  * The associated thread does <i>not</i>
  * {@linkplain Thread#setDaemon run as a daemon}.
  *
  * @param name the name of the associated thread
  * @throws NullPointerException if {@code name} is null
  * @since 1.5
  */
 public Timer(String name) {
  thread.setName(name);
  thread.start();
 }

可以看出每创建一个Timer就是启动一个新的线程，那么启动的线程不是守护线程，所以一直运行。那我们该如何将新创建的的Timer改成守护线程呢？更改如上的代码：

package day003;

import java.util.Calendar;
import java.util.Date;
import java.util.Timer;

/**
*
* 项目名称：JavaThread
* 类名称：TimerTaskRun
* 类描述：
* 创建人：liuc
* 创建时间：2018年3月19日 下午3:08:01
* 修改人：liuc
* 修改时间：2018年3月19日 下午3:08:01
* 修改备注：
* @version
*
*/
public class TimerTaskRun {
 public static void main(String[] args) {
  System.out.println("系统当前时间："+new Date());
  Calendar calendar = Calendar.getInstance();
  calendar.add(Calendar.SECOND, 10);
  Date date = calendar.getTime();
  MyTask task = new MyTask();
  Timer timer = new Timer(true);
  timer.schedule(task, date);
 }
}

运行结果如下：

系统当前时间：Mon Mar 19 15:21:42 CST 2018

守护线程中产生的线程也是守护线程
如下示例：

package day003;

/**
*
* 项目名称：JavaThread
* 类名称：Daemon
* 类描述：
* 创建人：liuc
* 创建时间：2018年3月19日 下午3:30:53
* 修改人：liuc
* 修改时间：2018年3月19日 下午3:30:53
* 修改备注：
* @version
*
*/
public class Daemon implements Runnable {
 private Thread[] t = new Thread[10];

 /**
 * (non-Javadoc)
 * @see java.lang.Runnable#run()
 */
 public void run() {
  for (int i = 0; i < t.length; i++) {
   t[i] = new Thread(new DaemonSpawn());
   t[i].start();
   System.out.println("DaemonSpawn " + i + " started.");
  }
  for (int i = 0; i < t.length; i++) {
   System.out.println("t[" + i + "].isDaemon() = " + t[i].isDaemon() + ".");
  }
  while (true) {
   Thread.yield();
  }
 }
}
-----------------------------------------------------------------------------------
package day003;

/**
*
* 项目名称：JavaThread
* 类名称：DaemonSpawn
* 类描述：
* 创建人：liuc
* 创建时间：2018年3月19日 下午3:32:06
* 修改人：liuc
* 修改时间：2018年3月19日 下午3:32:06
* 修改备注：
* @version
*
*/
public class DaemonSpawn implements Runnable {

 /**
 * (non-Javadoc)
 * @see java.lang.Runnable#run()
 */
 public void run() {
  while (true) {
   Thread.yield();
  }
 }
}
-----------------------------------------------------------------------------------
package day003;

import java.util.concurrent.TimeUnit;
/**
*
* 项目名称：JavaThread
* 类名称：DaemonRun
* 类描述：
* 创建人：liuc
* 创建时间：2018年3月19日 下午3:36:34
* 修改人：liuc
* 修改时间：2018年3月19日 下午3:36:34
* 修改备注：
* @version
*
*/
public class DaemonRun {
 public static void main(String[] args) throws InterruptedException {
  Thread d = new Thread(new Daemon());
  d.setDaemon(true);//必须在启动线程前调用
  d.start();
  System.out.println("d.isDaemon() = " + d.isDaemon() + ".");
  TimeUnit.SECONDS.sleep(1);
 }
}

运行结果如图：

d.isDaemon() = true.
DaemonSpawn 0 started.
DaemonSpawn 1 started.
DaemonSpawn 2 started.
DaemonSpawn 3 started.
DaemonSpawn 4 started.
DaemonSpawn 5 started.
DaemonSpawn 6 started.
DaemonSpawn 7 started.
DaemonSpawn 8 started.
DaemonSpawn 9 started.
t[0].isDaemon() = true.
t[1].isDaemon() = true.
t[2].isDaemon() = true.
t[3].isDaemon() = true.
t[4].isDaemon() = true.
t[5].isDaemon() = true.
t[6].isDaemon() = true.
t[7].isDaemon() = true.
t[8].isDaemon() = true.
t[9].isDaemon() = true.

如果将mian函数中的TimeUnit.SECONDS.sleep(1);注释掉，看一下TimeUnit.SECONDS.sleep()的源码：

/**
  * Performs a {@link Thread#sleep(long, int) Thread.sleep} using
  * this time unit.
  * This is a convenience method that converts time arguments into the
  * form required by the {@code Thread.sleep} method.
  *
  * @param timeout the minimum time to sleep. If less than
  * or equal to zero, do not sleep at all.
  * @throws InterruptedException if interrupted while sleeping
  */
 public void sleep(long timeout) throws InterruptedException {
  if (timeout > 0) {
   long ms = toMillis(timeout);
   int ns = excessNanos(timeout, ms);
   Thread.sleep(ms, ns);
  }
 }

其实就是对Thread.sleep()的封装，提供了可读性更好的线程暂停操作

注释后代码运行如下：

d.isDaemon() = true.

以上结果也说明了如果用户线程全部退出了，只剩下守护线程存在了，虚拟机也就退出了。

典型的守护线程是(GC)垃圾回收线程。

package day003;


/**
*
* 项目名称：JavaThread
* 类名称：MyThread
* 类描述：
* 创建人：liuc
* 创建时间：2018年3月19日 下午3:50:12
* 修改人：liuc
* 修改时间：2018年3月19日 下午3:50:12
* 修改备注：
* @version
*
*/
public class MyThread extends Thread{
 private int i = 0;
 /**
 * (non-Javadoc)
 * @see java.lang.Thread#run()
 */

 public void run() {
  super.run();
  try {
   while (true) {
    i++;
    System.out.println("i="+i);
    Thread.sleep(1000);
   }
  } catch (Exception e) {
   e.printStackTrace();
  }

 }

 public static void main(String[] args) throws InterruptedException {
  MyThread daemonThread = new MyThread();
  daemonThread.setDaemon(true);
  daemonThread.start();
  Thread.sleep(5000);
  System.out.println("当main线程执行完毕，守护线程也停止了。");
 }
}

运行结果：

i=1
i=2
i=3
i=4
i=5
当main线程执行完毕，守护线程也停止了。

除 JVM 内部的守护线程外，用户可以通过以下方法设置守护线程：

public final void setDaemon(boolean on)

可以通过以下方法查询线程是否为守护线程：

public final boolean isDaemon()

关于守护线程的几个要点：

1、setDaemon 方法必须在 thread.start() 之前设置，否则会抛出 java.lang.IllegalThreadStateException 异常，不能将正在运行的常规线程设置为守护线程

package day003;

/**
*
* 项目名称：JavaThread
* 类名称：TestDaemon
* 类描述：
* 创建人：liuc
* 创建时间：2018年3月19日 下午4:01:32
* 修改人：liuc
* 修改时间：2018年3月19日 下午4:01:32
* 修改备注：
* @version
*
*/
public class TestDaemon {
 public static void main(String[] args) {
  Thread thread = new Thread();
  thread.start();
  thread.setDaemon(true);
 }
}

运行结果：

Exception in thread "main" java.lang.IllegalThreadStateException
at java.lang.Thread.setDaemon(Thread.java:1359)
at day003.TestDaemon.main(TestDaemon.java:32)

2、不是所有的应用都可以分配给 Daemon 线程来进行服务，比如读写操作或者计算逻辑，因为在 Daemon 线程还没来的及进行操作时虚拟机可能已经退出了

package day003;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

/**
*
* 项目名称：JavaThread
* 类名称：TestDaemon2
* 类描述：
* 创建人：liuc
* 创建时间：2018年3月19日 下午4:03:22
* 修改人：liuc
* 修改时间：2018年3月19日 下午4:03:22
* 修改备注：
* @version
*
*/
public class TestDaemon2 extends Thread{

 /**
 * (non-Javadoc)
 * @see java.lang.Thread#run()
 */

 public void run() {
  super.run();
  FileOutputStream outputStream = null;
  try {
   Thread.sleep(3000);
   File file = new File("daemon.txt");
   outputStream = new FileOutputStream(file);
   outputStream.write("daemon".getBytes());
  } catch (InterruptedException e) {
   e.printStackTrace();
  } catch (IOException e) {
   e.printStackTrace();
  } finally {
   if (outputStream != null) {
    try {
     outputStream.close();
    } catch (IOException e) {
     e.printStackTrace();
    }
   }
  }
 }
 public static void main(String[] args) {
  Thread thread = new TestDaemon2();
  thread.setDaemon(true);
  thread.start();
 }

以上代码中线程功能是向工程根目录的“daemon.txt”文件写入字符串“daemon”，实际运行结果发现并未成功写入，且未报任何错误，原因是写入文件的线程被设置为守护线程，该线程还在 sleep 过程中时所有用户线程就全部结束了，守护线程也会随着 JVM 一起退出。

如果将上面代码中的thread.setDaemon(true);注释掉，

 public static void main(String[] args) {
  Thread thread = new TestDaemon2();
  //thread.setDaemon(true);
  thread.start();
 }

不将线程设置为守护线程可以在工程根目录的“daemon.txt”文件中看到字符串“daemon”

示例2：

package day003;

/**
*
* 项目名称：JavaThread
* 类名称：CustomThread
* 类描述：
* 创建人：liuc
* 创建时间：2018年3月19日 下午4:16:42
* 修改人：liuc
* 修改时间：2018年3月19日 下午4:16:42
* 修改备注：
* @version
*
*/
public class CustomThread extends Thread {

 /**
 * (non-Javadoc)
 * @see java.lang.Thread#run()
 */
 public void run() {
  super.run();
  for (int i = 0; i < 100; i++) {
   System.out.println("Daemon Thread : " + i);
  }
 }

 public static void main(String[] args) {
  Thread daemonThread = new CustomThread();
  daemonThread.setDaemon(true);
  Thread userThread = new Thread();
  daemonThread.start();
  userThread.start();
 }
}

多次执行示例2代码，控制台要么不打印任何信息，要么打印一部分循环的输出信息就结束了，从运行结果可以看出，守护线程并未执行完成所有循环就结束了，因为用户线程在守护线程执行循环的过程中就已全部结束，守护线程也随着 JVM 一起结束。

以上所述是小编给大家介绍的java守护线程与非守护线程详解整合，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对脚本之家网站的支持！

您可能感兴趣的文章:

Java核心库实现简单的AOP
这篇文章主要介绍了如何用Java核心库实现简单的AOP，帮助大家为了更好的理解和学习AOP的思想，感兴趣的朋友可以了解下
2020-08-08
Java 中的垃圾回收机制详解
这篇文章主要为大家详细介绍了Java垃圾回收机制的相关资料，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2021-09-09
Spring实现默认标签解析流程
这篇文章主要为大家详细介绍了Spring实现默认标签解析流程，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2022-01-01
Java 实现分布式服务的调用链跟踪
分布式服务中完成某一个业务动作，需要服务之间的相互协作才能完成，在这一次动作引起的多服务的联动我们需要用1个唯一标识关联起来，关联起来就是调用链的跟踪。本文介绍了Java 实现分布式服务的调用链跟踪的步骤
2021-06-06
Mybatis查不到数据查询返回Null问题
mybatis突然查不到数据，查询返回的都是Null，但是 select count(*) from xxx查询数量，返回却是正常的。好多朋友遇到这样的问题不知所措，下面小编通过本教程简单给大家说明下
2016-08-08
Java中的SPI机制使用解析
这篇文章主要介绍了Java中的SPI机制使用解析,SPI意思是"服务提供者的接口",专门提供给服务提供者或者扩展框架功能的开发者去使用的接口,SPI 将服务接口和服务实现分离开来,将服务调用方和服务实现方进行解耦,需要的朋友可以参考下
2023-10-10
第一次编写Java流布局图形界面
这篇文章主要为大家详细介绍了第一次编写Java流布局图形界面的相关代码，感兴趣的小伙伴们可以参考一下
2016-08-08
详解Mybatis分页插件 - 示例代码
这篇文章主要介绍了详解Mybatis分页插件 - 示例代码,小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧。
2016-12-12
Java实现对一行英文进行单词提取功能示例
这篇文章主要介绍了Java实现对一行英文进行单词提取功能,结合实例形式分析了java基于StringTokenizer类进行字符串分割的相关操作技巧,需要的朋友可以参考下
2017-10-10
Spring Security权限想要细化到按钮实现示例
这篇文章主要为大家介绍了Spring Security权限想要细化到按钮实现示例，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2022-07-07

【java 多线程】守护线程与非守护线程的详解

相关文章

最新评论

大家感兴趣的内容

最近更新的内容

常用在线小工具