import java.util.concurrent.TimeUnit;

/**
 * InnerThread1 建立了一個擴充套件自Thread 的匿名內部類，
 * 並且在構造器中建立了一個內部類的一個例項。如果內部類
 * 具有你在其他方法中需要訪問的特殊能力（新方法），那這麼
 * 做將會很有意義。但是，在大多數時候，建立執行緒的原因只是為
 * 了使用Thread的能力，因此不必要建立匿名內部類。
 * 
 * @create @author Henry @date 2016-11-18
 */
// using a named inner class:
class InnerThread1 {
	private int countDown = 5;
	private Inner inner;

	private class Inner extends Thread {
		public Inner(String name) {
			super(name);
			start();
		}

		@Override
		public void run() {
			try {
				while (true) {
					System.out.println(this);
					if (--countDown == 0)
						return;
					sleep(10);
				}
			} catch (InterruptedException e) {
				System.out.println("interrupted");
			}
		}

		@Override
		public String toString() {
			return getName() + ": " + countDown;
		}
	}

	public InnerThread1(String name) {
		inner = new Inner(name);
	}
}

/**
 * InnerThread2展示了可替換的方式：在構造器中建立一個匿名的Thread子類，
 * 並且將其向上轉型為Thread引用t.如果類中的其他方法需要訪問t,那它們可以
 * 通過Thread介面來實現，並且不需要了解該物件的確切型別。
 * 
 * @create @author Henry @date 2016-11-18
 * 
 */
// Using an anonymous inner class:
class InnerThread2 {
	private int countDown = 5;
	private Thread t;

	public InnerThread2(String name) {
		t = new Thread(name) {
			@Override
			public void run() {
				try {
					while (true) {
						System.out.println(this);
						if (--countDown == 0)
							return;
						sleep(10);
					}
				} catch (InterruptedException e) {
					System.out.println("sleep() interrupted");
				}
			}

			public String toString() {
				return getName() + ":" + countDown;
			};
		};
		t.start();
	}
}

/**
 * 參考InnerThread1
 * 
 * @create @author Henry @date 2016-11-18
 * 
 */
// Using a named Runnable implememtation
class InnerRunnable1 {
	private int countDown = 5;
	private Inner inner;

	private class Inner implements Runnable {
		Thread t;

		public Inner(String name) {
			t = new Thread(this, name);
			t.start();
		}

		@Override
		public void run() {
			try {
				while (true) {
					System.out.println(this);
					if (--countDown == 0)
						return;
					TimeUnit.MILLISECONDS.sleep(10);
				}
			} catch (InterruptedException e) {
				System.out.println("sleep() interrupted");
			}
		}

		@Override
		public String toString() {
			return t.getName() + ":" + countDown;
		}
	}

	public InnerRunnable1(String name) {
		inner = new Inner(name);
	}
}

/**
 * 參考InnerThread2
 * 
 * @create @author Henry @date 2016-11-18
 * 
 */
// Using an anonymous Runnable implementation:
class InnerRunnable2 {
	private int countDown = 5;
	private Thread t;

	public InnerRunnable2(String name) {
		t = new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					while (true) {
						System.out.println(this);
						if (--countDown == 0)
							return;
						TimeUnit.MILLISECONDS.sleep(10);
					}
				} catch (InterruptedException e) {
					System.out.println("sleep() interrupted");
				}
			}

			@Override
			public String toString() {
				return Thread.currentThread().getName() + ":" + countDown;
			}
		}, name);
		t.start();
	}
}

/**
 * ThreadMethod類展示了在方法內部如何建立執行緒。當你準備好執行執行緒時，
 * 就可以呼叫這個方法，而線上程開始之後，該方法將返回。如果該執行緒只執行輔助操作，
 * 而不是該類的重要操作，那麼這與在該類的構造器內部啟動執行緒相比，
 * 可能是一種更加有用而適合的方式。
 * 
 * @create @author Henry @date 2016-11-18
 * 
 */
// A separate method to run some code as a tack:
class ThreadMethod {
	private int countDown = 5;
	private Thread t;
	private String name;

	public ThreadMethod(String name) {
		this.name = name;
	}

	public void runTask() {
		if (t == null) {
			t = new Thread(name) {
				public void run() {
					try {
						while (true) {
							System.out.println(this);
							if (--countDown == 0)
								return;
							TimeUnit.MILLISECONDS.sleep(10);
						}
					} catch (InterruptedException e) {
						System.out.println("sleep() interrupted");
					}
				}

				public String toString() {
					return getName() + ":" + countDown;
				};
			};
			t.start();
		}
	}
}

/**
 * 在構造器中啟動執行緒可能會變得很有問題，因為另一個任務可能會在構造器結束之前
 * 開始執行，這意味著該任務能夠訪問處於不穩定狀態的物件。這是優先Executor而不
 * 是顯式地建立Thread物件的另一個原因。
 * 有時通過使用內部類來將執行緒程式碼隱藏在類中將會很有用，就像如下這樣:
 * 
 * @create @author Henry @date 2016-11-18
 */
public class ThreadVariations {

	public static void main(String[] args) {
		new InnerThread1("InnerThread1");
		new InnerThread2("InnerThread2");
		new InnerRunnable1("InnerRunnable1");
		new InnerRunnable2("InnerRunnable2");
		new ThreadMethod("ThreadMethod").runTask();
	}
}