/*必須在啟動線程之前調用SetDaemon()方法，才能把這個線程設置為后臺線程。
* 在這個程序里面，當我們輸入了字符串以后，那么Main線程就會停止運行了
* 那么程序中已經(jīng)沒有可以運行的用戶的線程了。所以后臺線程就會被停止了
* JVM也就會被停停止了，感興趣的讀者可以自己嘗試一下*/
public class DaemonRunner implements Runnable {
	@Override
	 public void run() {
		while (true) {
			for (int i = 0; i < 3; i++) {
				System.out.println("守護線程" + i);
			}
		}
	}
	public static void main(String[] args) {
		Thread daemon = new Thread(new DaemonRunner());
		daemon.setDaemon(true);
		daemon.start();
		Scanner s = new Scanner(System.in);
		String string=s.nextLine();
		Runtime.getRuntime().addShutdownHook(new Thread(){
			@Override
			   public void run() {
				super.run();
				System.out.println("JVM退出");
				try {
					TimeUnit.MILLISECONDS.sleep(50);
				}
				catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
		);
	}
}

/*可以通過調用isDaemon()方法來確定線程是否是一個后臺線程。如果是一個后臺線程，
* 那么它創(chuàng)建的任何線程都被自動設置成后臺的線程
* 在這個實例中，Daemon線程被設置成了后臺模式，然后派生出許多子線程，這些線程并沒有被設置成
* 后臺模式，不過它們的確是后臺線程。接著，Daemon線程進入了無限循環(huán)，并且在循環(huán)里調用了yield方法
* 把控制權交給其它的線程或者進程*/
class Daemon implements Runnable{
	private Thread[] t = new Thread[10];
	@Override
	 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();
		}
	}
}
class DaemonSpawn implements Runnable{
	@Override
	 public void run() {
		while (true) {
			Thread.yield();
		}
	}
}
public class Daemons {
	public static void main(String[] args) {
		Thread d = new Thread(new Daemon());
		d.setDaemon(true);
		d.start();
		System.out.println("d.isDaemon()=" + d.isDaemon());
		try {
			TimeUnit.SECONDS.sleep(1);
			//讓啟動的后臺的線程可以獲得一定的執(zhí)行的時間。
		}
		catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

/*在這個例子中，對于這個靜態(tài)的構造方法：Executors.newCachedThreadPool(new DaemonThreadFactory()
* 我們可以為傳入一個ThreadFactory的對象，那么我們就可以通過這種方法，將我們想要啟動的線程設置為后臺線程
* 這是要注意的。*/
class DaemonThreadFactory implements ThreadFactory{
	@Override
	  public Thread newThread(Runnable r) {
		Thread t = new Thread(r);
		t.setDaemon(true);
		return t;
	}
}
/*在這個例子中，在Main方法中，會首先調用Main方法中的普通的方法，“ System.out.println("All dameons started");”
* 所以會首先打印這一條語句。然后在主線程休眠期間，相應的后臺線程，就會獲得執(zhí)行的時間，最后在Main線程
* 結束了運行的時候，也就是當Main線程從休眠中恢復過來的時候，那么Main線性就會結束運行。接著，
* 那么所有的后臺的線程都會停止。JVM也會停止執(zhí)行。*/
public class DaemonFromFactory implements Runnable {
	@Override
	  public void run() {
		try {
			while (true) {
				TimeUnit.MILLISECONDS.sleep(100);
				System.out.println(Thread.currentThread() + " " + this);
			}
		}
		catch (InterruptedException e) {
			System.out.println("Interrupted");
		}
	}
	public static void main(String[] args) {
		ExecutorService exec = Executors.newCachedThreadPool(new DaemonThreadFactory());
		for (int i = 0; i < 10; i++) {
			exec.execute(new DaemonFromFactory());
		}
		System.out.println("All dameons started");
		try {
			TimeUnit.MILLISECONDS.sleep(500);
		}
		catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

/*當你調用這個程序的時候，你將看到finally子句不會執(zhí)行，但是如果你注釋掉對setDaemon()的調用，你將看到
* finally 子句將會執(zhí)行.
* 這種行為是正確的。即便你基于前面對finally給出的承諾，并不希望出現(xiàn)這種行為。但是情況就是這樣
* 當最后一個非后臺的線程終止的時候，后臺線程就會突然的停止。因為一旦main()退出后，JVM就會立即關閉所有后臺的
* 線程。因為你不能以優(yōu)雅的方式來關閉后臺線程，所以它們幾乎不是一種好的思想。非后臺的Executor通常是一種
* 更好的方式，因為Executor控制的所有的任務可以同時被關閉。*/
class ADaemon implements Runnable{
  @Override
  public void run() {
    System.out.println("Starting ADaemon");
    try {
      TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
      System.out.println("Exiting via InterruptedException");
    }finally {
      System.out.println("This should always run?");
    }
  }
}
public class DaemonsDontRunFinally {
  public static void main(String[] args) {
    Thread t = new Thread(new ADaemon());
    t.setDaemon(true);
    t.start();
  }
}

class ADaemon implements Runnable{
  @Override
  public void run() {
    System.out.println("Starting ADaemon");
    try {
      TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
      System.out.println("Exiting via InterruptedException");
    }finally {
      System.out.println("This should always run?");
    }
  }
}
public class DaemonsDontRunFinally {
  public static void main(String[] args) {
    Thread t = new Thread(new ADaemon());
    t.setDaemon(true);
    t.start();
    try {
      TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }
}