執行緒安全是指多個執行緒訪問同一程式碼，不會產生不確定的結果；

執行緒同步：

為了避免多執行緒在共享資源時發生衝突，所以 要線上程使用該資源時，就為執行緒上一把“鎖”，第一個訪問資源的執行緒為資源上鎖，其他執行緒若想訪問該資源，則必須等待解鎖為止，解鎖的同時，另一個執行緒訪問資源併為資源上鎖。

在使用多執行緒程式設計時，一般解決同步問題的方法有三種種：

1. 用synchronize關鍵字：

2. wait()方法和notify()或notifyAll()方法：當使用synchronize來修飾某個共享資源時，如果執行緒A在執行synchronize程式碼塊，另外一個執行緒B也要執行同一物件的同一synchronize程式碼時，執行緒B將要等到執行緒A釋放物件鎖，才能繼續執行，這時可以使用wait()方法和notify()方法；
3. 還有一種非常靈活簡便的同步鎖可以選擇，可以通過java.util.concurrent.locks.ReentrntLock類 的物件呼叫lock()方法來實現加鎖操作，此時可以進行同步操作，同步操作結束後，呼叫unlock()釋放同步鎖。（在呼叫同一物件的wait()和notify()方法語句必須放在同步程式碼塊中，並且同步程式碼塊使用該物件的同步鎖，否則在執行時會丟擲ILLegalMonitorStateException）異常。

synchronized加在例項方法上，鎖的是物件例項；加在靜態方法上鎖的是類。

同步程式碼塊：
synchronize(Object obj) {
     //需要同步的程式碼塊，這個地方會訪問obj的程式碼
}
同步方法：
【訪問控制符】 【static|final】synchronize 返回型別 方法名（引數列表）{
         //需要同步的程式碼
         【return 返回值】
}

其中，synchronize實現同步程式碼塊的關鍵字，obj表示任意物件，可以是實際存在的也可以是假設的，在Java中任意一個物件都有一個同步鎖，以下是注意事項：

• 物件O的同步鎖在任何時刻最多隻能被一個執行緒擁有；
• 如果物件O的同步鎖被執行緒T擁有，那麼當其他執行緒來訪問O時，這些執行緒將被放到O的鎖池中，並將它們轉為同步阻塞狀態；
• 擁有O的鎖的執行緒T執行完後，會自動釋放O的鎖。若在執行過程中，執行緒T發生異常退出，也將自動釋放O的鎖；
• 如果執行緒T在執行同步程式碼塊時，呼叫了O的wait()方法，則執行緒T會釋放O的鎖，執行緒T也將轉為等待阻塞狀態；
• 如果執行緒T在執行同步程式碼塊時，呼叫了Thread類的sleep（）方法，執行緒T將放棄執行權，即放棄CPU，但執行緒T不會放棄物件O的鎖；
• 如果執行緒T釋放了物件O的鎖，並放棄執行權，則CPU將會隨機分配給物件O鎖池中的執行緒，該執行緒也將會擁有物件O鎖；

/**
 * 一個鍋裡有五碗飯，有兩個視窗，一次只能給一個人打飯。
 * @author lzq
 *
 */
class Ticket implements Runnable {
	private int ticket = 5;
	public Ticket() {
		
	}
	public void run() {
		while(ticket >= 1) {
			this.sale();
			}
		}
	/**
	 * 同步方法
	 */
	private void sale() {
		if(ticket > 0) {
			try {
				Thread.sleep(1000);
			}catch(InterruptedException e) {
				e.printStackTrace();
			}
			if(ticket > 0) {
				System.out.println("------"+Thread.currentThread().getName()+"賣出第"
			+(ticket--)+"碗飯");
			}
		}
		
	}
}

/**
 * 兩個視窗賣票，一次賣一張，總共5張
 * 使用同步程式碼塊
 * @author lzq
 *
 */
public class TestDemo13 implements Runnable {
	private int ticket = 5;
	public TestDemo13() {
		
	}
	public void run() {
		while(ticket >= 1) {
			synchronized (this) {
				try {
					Thread.sleep(1000);
				}catch(InterruptedException e) {
					e.printStackTrace();
				}
				if(ticket > 0) {
					System.out.println(Thread.currentThread().getName()+"賣出第"
				+(ticket--)+"張門票");
				}
			}
		}
	}

	
	public static void main(String[] args) {
		TestDemo13 x = new TestDemo13();
		
		Thread t1 = new Thread(x,"第一視窗");
		Thread t2 = new Thread(x,"第二視窗");
		t1.start();
		t2.start();
		
		Ticket y = new Ticket();
		Thread z1 = new Thread(y,"第1視窗");
		Thread z2 = new Thread(y,"第2視窗");
		z1.start();
		z2.start();

	}

}

執行結果：

------第2視窗賣出第5碗飯
------第1視窗賣出第4碗飯
第一視窗賣出第5張門票
第一視窗賣出第4張門票
------第2視窗賣出第2碗飯
------第1視窗賣出第3碗飯
------第2視窗賣出第1碗飯
第一視窗賣出第3張門票
第一視窗賣出第2張門票
第一視窗賣出第1張門票

/**
 * 使用同步鎖實現
 * 兩個視窗賣票，一次賣一張，總共10張
 * @author lzq
 *
 */
public class TestDemo14 implements Runnable {
	private final ReentrantLock lock = new ReentrantLock();//建立鎖
	private int ticket = 10;
	public TestDemo14() {
		
	}
	public void run() {
		while(ticket > 0) {
			lock.lock();   //加鎖
			try {
				Thread.sleep(1000);
			}catch(InterruptedException e) {
				e.printStackTrace();
			}
			if(ticket > 0) {
				System.out.println(Thread.currentThread().getName()+"賣出第"
				+(ticket--)+"張門票");
			}
			lock.unlock();//釋放鎖
		}
	}


	
	public static void main(String[] args) {
        TestDemo14 x = new TestDemo14();
		
		Thread t1 = new Thread(x,"第一視窗");
		Thread t2 = new Thread(x,"第二視窗");
		t1.start();
		t2.start();

	}

}

執行結果：

第一視窗賣出第10張門票
第一視窗賣出第9張門票
第一視窗賣出第8張門票
第二視窗賣出第7張門票
第二視窗賣出第6張門票
第二視窗賣出第5張門票
第二視窗賣出第4張門票
第一視窗賣出第3張門票
第一視窗賣出第2張門票
第一視窗賣出第1張門票

範例：

1. 有兩個執行緒分別為sf和gf，sf用來放置食物，而gf用來取走食物；
2. sf一次只能放置一批次食物，sf放置好後通知gf取走；
3. gf一次只能取走一批次的食物，等到gf取走食物後通知sf放置食物；
4. sf不放置食物，則gf不能取走食物，若gf沒有取走食物，則sf不能放置食物；
5. 開始時，先由sf放置，再由gf取走；

/**
 * 放置食物類
 * @author lzq
 *
 */
class SetFood implements Runnable {
	private Food food;
	public SetFood(Food food) {
		this.food = food;
	}
	public void run() {
		for(int number = 1;number <= 5;number++) {
			try {
				Thread.sleep(500);
			}catch(InterruptedException e) {
				e.printStackTrace();
			}
			food.setfood(number);  //放置食物
		}
	}
}
/**
 * 取走食物類
 * @author lzq
 *
 */
class GetFood implements Runnable {
	private Food food;
	public GetFood(Food food) {
		this.food = food;
	}
	public void run() {
		for(int number = 1;number <= 5;number++) {
			try {
				Thread.sleep(500);
			}catch(InterruptedException e) {
				e.printStackTrace();
			}
			food.getfood();  //取走食物
		}
	}
}
/**
 * 食物類
 * @author lzq
 *
 */
public class Food {
	private int number = 0; //食物批次
	private String food = null; //食物名稱
	public Food() {
		
	}
	public Food(String food,int number) {  
		this.food = food;
		this.number = number;
	}
	/**
	 * 放置食物
	 * @param n
	 */
	public synchronized void setfood(int n) {   
		if(this.number != 0) {
			try {
				wait();   //開始等待
			}catch(InterruptedException e) {
				e.printStackTrace();
			}
		}
		number = n;
		System.out.println("放置"+this.food+"第"+this.number+"批次");
		notify();  //通知取走食物
	}
	/**
	 * 取走食物
	 * @param n
	 * @return
	 */
	public synchronized String getfood() {
		if(this.number == 0) {
			try {
				wait();  //等待放置食物
			}catch(InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("\t取走"+"第"+this.number+"批次"+this.food);
		this.number = 0;
		notify();   //通知放置食物
		return food+number;   
		
	}
	
	public static void main(String[] args) {
		Food f= new Food("白菜",0);
		SetFood sf = new SetFood(f);
		GetFood gf = new GetFood(f);
		new Thread(sf).start();
		new Thread(gf).start();

	}

}

執行結果：

放置白菜第1批次
	取走第1批次白菜
放置白菜第2批次
	取走第2批次白菜
放置白菜第3批次
	取走第3批次白菜
放置白菜第4批次
	取走第4批次白菜
放置白菜第5批次
	取走第5批次白菜