java多线程之守护线程和用户线程

        Java中的线程分为两类：守护线程和用户线程，守护线程被称为后台线程、用户线程被称为前台线程。守护线程一般被用来服务用户线程，两者之间的区别就是体现在JVM的运行上，当所有的用户线程结束，JVM会自动退出，这时候系统服务停止运行，守护线程自然也只能被迫停止。反之，守护线程全部结束不一定会导致JVM退出。

        守护线程和用户线程在使用上区别不大，守护线程只需要在使用时执行this.setDaemon(true)方法，且这个方法必须放在this.start()方法之前执行，否则会抛出IllegalThreadStateException异常，JDK源码中此方法上的注释也已经明确指出使用时的注意事项。

/**
     * Marks this thread as either a daemon thread or a user thread. The 
     * Java Virtual Machine exits when the only threads running are all 
     * daemon threads. 
     * 

     * This method must be called before the thread is started. 
      * 

     * This method first calls the checkAccess method 
     * of this thread 
     * with no arguments. This may result in throwing a 
     * SecurityException (in the current thread). 
    *
     * @param      on   if true, marks this thread as a
     *                  daemon thread.
     * @exception  IllegalThreadStateException  if this thread is active.
     * @exception  SecurityException  if the current thread cannot modify
     *               this thread.
     * @see        #isDaemon()
     * @see        #checkAccess
     */
    public final void setDaemon(boolean on) {
	checkAccess();
	if (isAlive()) {
	    throw new IllegalThreadStateException();
	}
	daemon = on;
    }

下面用一个例子来比较下守护线程和用户线程的执行情况：

package com.zw;

/**
 * 守护线程和用户线程
 * @author Administrator
 * 用户线程结束，JVM也就退出了，守护线程会立刻终止
 */
public class TestDaemon {

	public static void main(String[] args) {
		
		MyUserThread m = new MyUserThread();
		MyUserThread2 m2 = new MyUserThread2();
		MyDaemonThread md = new MyDaemonThread(m, m2);
		md.setDaemon(true); //设置md为守护线程
		md.start();
	}
}

/**
 * 守护线程
 * @author Administrator
 *
 */
class MyDaemonThread extends Thread {

	MyUserThread m = null;
	MyUserThread2 m2 = null;
	
	MyDaemonThread(MyUserThread m,MyUserThread2 m2) {
		this.m = m;
		this.m2 = m2;
		m.start();
		m2.start();
	}
	
	@Override
	public void run() {
		// TODO Auto-generated method stub
		super.run();
		while(true) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("守护线程	      " + m.getI());
		}
	}
}

/**
 * 用户线程
 * @author Administrator
 *
 */
class MyUserThread extends Thread {
private int i = 0;
	
	public int getI()
	{
		return i;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		super.run();
		while(i < 5) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("用户线程	      " + i++);
		}
	}
}

class MyUserThread2 extends Thread {
	private int i = 0;
	
	public int getI()
	{
		return i;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		super.run();
		while(i < 10) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("用户线程2     " + i++);
		}
	}
}

执行结果：

用户线程          0
用户线程2     0
守护线程          1
用户线程          1
守护线程          2
用户线程2     1
用户线程          2
守护线程          3
用户线程2     2
用户线程          3
守护线程          4
用户线程2     3
用户线程          4
守护线程          5
用户线程2     4
守护线程          5
用户线程2     5
守护线程          5
用户线程2     6
守护线程          5
用户线程2     7
守护线程          5
用户线程2     8
守护线程          5
用户线程2     9

        上面的实例中启动了3个线程，一个守护线程md，两个用户线程m，m2。守护线程中无限循环执行输出，线程m执行结束时，守护线程还在自我循环中，但是当m2也结束时，守护线程也跟着停止了，这是因为m和m2两个用户线程全部结束，JVM检测到没有用户线程在执行，也就自动退出。JVM退出了，守护线程没了依托，也只能被迫停止。

        Java中的GC线程就是典型的守护线程，当系统停止了对象的创建，GC没有对象可回收，就会随着JVM退出而退出。