概念

Daemon，守护线程或者后台线程，是指程序运行的时候在后台提供的一种通用服务的线程，并且这种线程并不属于程序中不可或缺的部分。

当一个Java应用内，只有守护线程时，Java虚拟机就会自然退出；反过来说，当所有的非后台线程结束时，程序也就终止了，同时会杀死进程中的所有后台线程。

基本用法

/**
 * 设置为后台线程的线程会非后台线程的结束而被杀死
 */
public class Daemon {
    public static class DaemonThread extends Thread{
        @Override
        public void run() {
            while(true){
                System.out.println(" i am alive ");
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread deamon = new DaemonThread();
        deamon.setDaemon(true);    //将deamon设置为后台线程,必须在start之前设置
        deamon.start();
        /**
         * 如果在线程start之后设置,则会抛出java.lang.IllegalThreadStateException
         * 此异常是通知你守护线程设置失败,但是你的程序和线程依然可以正常执行，只是依然为用户线程而已
         */
    //    deamon.setDaemon(true);    
    //    此时,由于除deamon后台线程外,已经没有线程在运行了,主线程main一旦完成其工作,整个程序也随之结束
        Thread.sleep( 900 );    
    }
}

以上程序输出：

 i am alive 
 i am alive 
 i am alive

由于deamon线程被设置为后台线程，系统中只有main为用户线程，因此在主线程main休眠900毫秒之后，程序结束。

注意

• [ ] t.setDaemon()方法必须在start()之前
• [ ] 设置为后台线程后，不执行finally子句的情况下就会终止其run方法。

Daemon与finally

将上面的代码，DaemonThread 类修改一下

public static class DaemonThread extends Thread{
    @Override
    public void run() {
        while(true){
            System.out.print("i am alive ");
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.print( "finally run \r\n");
            }
        }
    }
}

main方法不变，程序将输出：

i am alive finally run 
i am alive finally run 
i am alive

你会发现run方法里的finally并没有得到执行，显然这与finally的语义相违背，但情况仍然如此。

扩展，线程池中的Daemon设置

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;

/**
 *    创建一个后台线程池
 */
public class DaemonExecutor {

    //第一步:编写定制的ThreadFactory，由Executor创建线程的属性
    public static class DaemonThreadFactory implements ThreadFactory{
        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r); 
        //  设置后台状态,与普通ThreadFactory的唯一差异
            t.setDaemon( true );
            return t;
        }
    }

    public static void main(String[] args) throws InterruptedException {
     // 第二步： 由DaemonThreadFactory创建出来的线程后台状态全部设置为了true
        ThreadFactory threadFactory = new DaemonThreadFactory();
     // 第三步：将DaemonThreadFactory作为参数传递给 
     //     Executors.newCachedThreadPool\Executors.newFixedThreadPool\Executors.newSingleThreadExecutor等
     //        使用DaemonThreadFactory来创建新的线程
        ExecutorService exec = Executors.newCachedThreadPool(threadFactory);
//        ExecutorService exec = Executors.newFixedThreadPool( 2, threadFactory);
//        ExecutorService exec = Executors.newSingleThreadExecutor(threadFactory);
        for( int i=0 ; i<2; i++ )
        exec.execute( new Runnable() {
            public void run() {
                while(true){
                    System.out.println( "alive " + Thread.currentThread().getId() );
                    try {
                        Thread.sleep(300);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        Thread.sleep( 900 );
    }
}