一、執行緒的幾種狀態

執行緒有四種狀態：

• 1.產生（New）：執行緒物件已經產生，但尚未被啟動，所以無法執行。如通過new產生了一個執行緒物件後沒對它呼叫start()函式之前。
• 2.可執行（Runnable）：每個支援多執行緒的系統都有一個排程器，排程器會從執行緒池中選擇一個執行緒並啟動它。
  當一個執行緒處於可執行狀態時，表示它可能正處於執行緒池中等待排排程器啟動它；也可能它已正在執行。
  如執行了一個執行緒物件的start()方法後，執行緒就處於可執行狀態，但顯而易見的是此時執行緒不一定正在執行中。
• 3.死亡（Dead）：當一個執行緒正常結束，它便處於死亡狀態。如一個執行緒的run()函式執行完畢後執行緒就進入死亡狀態。
• 4.停滯（Blocked）：當一個執行緒處於停滯狀態時，系統排程器就會忽略它，不對它進行排程。

二、執行緒間的相互作用

執行緒間的相互作用：執行緒之間需要一些協調通訊，來共同完成一件任務。

Object類中相關的方法有兩個notify方法和三個wait方法，因為wait和notify方法定義在Object類中，因此會被所有的類所繼承。這些方法都是final的，即它們都是不能被重寫的，不能通過子類覆寫去改變它們的行為。

1、wait()方法

• wait()方法使得當前執行緒必須要等待，等到另外一個執行緒呼叫notify()或者notifyAll()方法。
• 當前的執行緒必須擁有當前物件的monitor，也即lock，就是鎖。要確保呼叫wait()方法的時候擁有鎖，即，wait()方法的呼叫必須放在synchronized方法或synchronized塊中。
• 執行緒呼叫wait()方法，釋放它對鎖的擁有權，然後等待另外的執行緒來通知它（通知的方式是notify()或者notifyAll() 方法），這樣它才能重新獲得鎖的擁有權和恢復執行。

2、wait()與sleep()比較

• 當執行緒呼叫了wait()方法時，它會釋放掉物件的鎖。
• 另一個會導致執行緒暫停的方法：Thread.sleep()，它會導致執行緒睡眠指定的毫秒數，但執行緒在睡眠的過程中是不會釋放掉物件的鎖的。

3、notify()方法

• notify()方法會喚醒一個等待當前物件的鎖的執行緒。如果多個執行緒在等待，它們中的一個將會選擇被喚醒。這種選擇是隨意的，和具體實現有關。（執行緒等待一個物件的鎖是由於呼叫了wait方法中的一個）。
• 被喚醒的執行緒是不能被執行的，需要等到當前執行緒放棄這個物件的鎖。被喚醒的執行緒將和其他執行緒以通常的方式進行競爭，來獲得物件的鎖。也就是說，被喚醒的執行緒並沒有什麼優先權，也沒有什麼劣勢，物件的下一個執行緒還是需要通過一般性的競爭。
• notify()方法應該是被擁有物件的鎖的執行緒所呼叫。換句話說，和wait()方法一樣，notify()方法要求在呼叫時執行緒已經獲得了物件的鎖，因此對這兩個方法的呼叫需要放在synchronized方法或 synchronized塊中。

4、一個執行緒變為一個物件的鎖的擁有者是通過下列三種方法：

• 1.執行這個物件的synchronized例項方法。
• 2.執行這個物件的synchronized語句塊。這個語句塊鎖的是這個物件。
• 3.對於Class類的物件，執行那個類的synchronized、static方法。

三.例項程式碼分析

public class Demo {
	private volatile int signal;
	public void set(int value) {
		this.signal = value;
	}
	public int get() {
		return signal;
	}
	
	public static void main(String[] args) {
		Demo d = new Demo();
		new Thread(new Runnable() {
			@Override
			public void run() {
				synchronized (d) {
					System.out.println("修改狀態的執行。。。");
					try {
						Thread.sleep(5000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					d.set(1);
					System.out.println("修改狀態。。。");
					d.notify();
				}
			}
		}).start();


		new Thread(new Runnable() {
			@Override
			public void run() {
				synchronized (d) {
					//等待signal為1開始執行，否則不能執行
					while(d.get() != 1) {
						try {
							d.wait();
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
					}
					//當訊號為1的時候，執行程式碼
					System.out.println("模擬程式碼的執行。。。"+d.get());
				}
			}
		}).start();
	}
}

public class Demo2 {
	private volatile int signal;
	//notify和wait必須放在同步方法或者同步程式碼塊裡面執行
	public synchronized void set() {
		this.signal = 1;
		System.out.println("叫醒執行緒之後休眠開始。。。。");
		//notify();//notify方法會隨機叫醒一個處於wait狀態的執行緒
		notifyAll();//notifyAll叫醒所有處於wait狀態的執行緒，爭奪到時間片的執行緒只有一個
		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	public synchronized int get() {
		System.out.println(Thread.currentThread().getName()+"   執行了。。。   ");
		if(signal!=1) {
			try {
				wait();//呼叫wait方法的時候會釋放拿到的鎖
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println(Thread.currentThread().getName()+"   執行完畢");
		return signal;
	}

	public static void main(String[] args) {
		Demo2 d = new Demo2();
		Target1 t1 = new Target1(d);
		Target2 t2 = new Target2(d);

		new Thread(t2).start();
		new Thread(t2).start();
		new Thread(t2).start();
		new Thread(t2).start();
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		new Thread(t1).start();
	}
}

public class Target1 implements Runnable{
	private Demo2 demo2;
	public Target1(Demo2 demo2) {
		this.demo2 = demo2;
	}
	@Override
	public void run() {
		demo2.set();
	}
}

public class Target2 implements Runnable{
	private Demo2 demo2;
	public Target2(Demo2 demo2) {
		this.demo2 = demo2;
	}
	@Override
	public void run() {
		demo2.get();
	}
}

原文