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退出而退出。


你可能感兴趣的:(java多线程)