线程中的setDaemon到底有什么用呢?

1. package cn.thread;
   
2. 
   
3. public class Demo8 {
   
4. 
   
5.         /**
   
6.          * @param args
   
7.          * @throws InterruptedException
   
8.          */
   
9.         public static void main(String[] args) throws InterruptedException {
   
10.                 // TODO Auto-generated method stub
    
11.                 ThTest th = new ThTest();
    
12.                
    
13.                
    
14.                 Thread t = new Thread(new Runnable(){
    
15.                         public void run(){
    
16.                                 for(int x = 0;x<10;x++){
    
17.                                         System.out.println("x = "+x);
    
18.                                         try {
    
19.                                                 Thread.sleep(1000);
    
20.                                         } catch (InterruptedException e) {
    
21.                                                 // TODO Auto-generated catch block
    
22.                                                 e.printStackTrace();
    
23.                                         }
    
24.                                 }
    
25.                         }
    
26.                 });
    
27.                
    
28.                 for(int m = 0;m<5;m++){
    
29.                         System.out.println("m = "+m);
    
30.                         Thread.sleep(1000);
    
31.                 }
    
32.                
    
33.                 t.setDaemon(true);
    
34.                 th.setDaemon(true);
    
35.                 t.start();
    
36.                 th.start();
    
37.                
    
38.         }       
    
39.                
    
40. }
    
41. 
    
42. class ThTest extends Thread{
    
43.         public void run(){
    
44.                 for(int i = 0;i<10;i++){
    
45.                         System.out.println("i = "+i);
    
46.                         try {
    
47.                                 Thread.sleep(1000);
    
48.                         } catch (InterruptedException e) {
    
49.                                 // TODO Auto-generated catch block
    
50.                                 e.printStackTrace();
    
51.                         }
    
52.                 }
    
53.         }
    
54. }

复制代码

运行的结果是:
m = 0
m = 1
m = 2
m = 3
m = 4
x = 0
i = 0

当for循环结束时,两个线程都都结束了,那写上有什么用呢?

守护线程：
1. setDaemon需要在start方法调用之前使用
2. 线程划分为用户线程和后台(daemon)进程，setDaemon将线程设置为后台进程
3. 如果jvm中都是后台进程，当前jvm将exit。（随之而来的，所有的一切烟消云散，包括后台线程啦）
4. 主线程结束后，
      1） 用户线程将会继续运行
      2） 如果没有用户线程，都是后台进程的话，那么jvm结束
另外：
setDaemon方法把java的线程设置为守护线程，此方法的调用必须在线程启动之前执行。只有在当前jvm中所有的线程都为守护线程时，jvm才会退出。

1. package com.itheima.bbs;
   
2. 
   
3. public class Demo8 {
   
4. 
   
5.         /**
   
6.          *
   
7.          * @param args
   
8.          *
   
9.          * @throws InterruptedException
   
10.          */
    
11. 
    
12.         public static void main(String[] args) throws InterruptedException {
    
13. 
    
14.                 // TODO Auto-generated method stub
    
15. 
    
16.                 ThTest th = new ThTest();
    
17.                 Thread t = new Thread(new Runnable() {
    
18.                         public void run() {
    
19.                                 for (int x = 0; x < 10; x++) {
    
20.                                         System.out.println("x = " + x);
    
21.                                         try {
    
22.                                                 Thread.sleep(1000);
    
23.                                         } catch (InterruptedException e) {
    
24.                                                 e.printStackTrace();
    
25. 
    
26.                                         }
    
27.                                 }
    
28.                         }
    
29.                 });
    
30. 
    
31.                 t.setDaemon(true);
    
32.                 th.setDaemon(true);
    
33.                 t.start();
    
34.                 th.start();
    
35.                 for (int m = 0; m < 5; m++) {
    
36.                         System.out.println("m = " + m);
    
37.                         Thread.sleep(1000);
    
38.                 }
    
39.         }
    
40. }
    
41. 
    
42. class ThTest extends Thread {
    
43. 
    
44.         public void run() {
    
45.                 for (int i = 0; i < 10; i++) {
    
46.                         System.out.println("i = " + i);
    
47.                         try {
    
48.                                 Thread.sleep(1000);
    
49.                         } catch (InterruptedException e) {
    
50.                                 e.printStackTrace();
    
51.                         }
    
52.                 }
    
53.         }
    
54. }

复制代码

输出结果：
m = 0
i = 0
x = 0
m = 1
i = 1
x = 1
m = 2
i = 2
x = 2
i = 3
m = 3
x = 3
m = 4
i = 4
x = 4
i = 5
x = 5

作用是可以让一个用户线程去控制jvm的退出，守护线程只能执行jvm退出之前的操作。

恩,知道了,谢谢你了~!