當多個執行緒併發訪問同一個資源物件時，可能會出現執行緒不安全的問題，比如現有50個蘋果,現在有請三個童鞋(小A,小B,小C)上臺表演吃蘋果.因為A,B,C三個人可以同時吃蘋果,此時使用多執行緒技術來實現這個案例.

class Apple implements Runnable{
	private int num = 50;//蘋果總數

	public void run() {
		for (int i = 0; i < 50; i++) {
			if (num > 0) {
				try {
					//模擬網路延遲
					Thread.sleep(100);
					System.out.println(Thread.currentThread().getName() + "吃了編號為"
							+ num-- + "的蘋果");
				} catch (Exception e) {
					e.printStackTrace();
				}
				
			}
		}
	}
	
}
public class AppleEatingImplements {
	public static void main(String[] args) {
		//建立三個執行緒（三個同學），吃蘋果
		Runnable apple = new Apple();
		new Thread(apple,"A童鞋").start();
		new Thread(apple,"B童鞋").start();
		new Thread(apple,"C童鞋").start();
	}

}
 

為什麼編號為39的蘋果被吃了兩次呢？

當A、B執行緒拿到編號為39的蘋果時，打印出來，有一個還沒來得及做num--，而有一個做了num減一操作，num還剩38，這時候執行緒進入睡眠狀態。這時候C執行緒來了，列印38，做減1操作，睡眠……

要解決上述多執行緒併發訪問多一個資源的安全性問題，就必須得保證列印蘋果編號和蘋果總數減1操作,必須同步完成.即是說，A執行緒進入操作的時候,B和C執行緒只能在外等著,A操作結束,A和B和C才有機會進入程式碼去執行.

解決多執行緒併發訪問資源的安全問題，有三種方式：

方式1:同步程式碼塊

方式2:同步方法

方式3:鎖機制(Lock)

方式

語法:

synchronized(同步鎖)

{

     需要同步操作的程式碼

}

同步鎖:

為了保證每個執行緒都能正常執行原子操作,Java引入了執行緒同步機制.也稱為同步監聽物件/同步鎖/同步監聽器/互斥鎖。

實際上，物件的同步鎖只是一個概念,可以想象為在物件上標記了一個鎖，誰拿到鎖，誰就可以進入程式碼塊，其他執行緒只能在程式碼塊外面等著，而且注意，在任何時候，最多允許一個執行緒擁有同步鎖.

Java程式執行可以使用任何物件作為同步監聽物件,但是一般的,我們把當前併發訪問的共同資源作為同步監聽物件.

//同步程式碼塊
class Apple2 implements Runnable{
	private int num = 100;
	public void run() {
		for(int i = 0; i < 50; i ++){
			//this表示Apple2物件，該物件屬於多執行緒共享的資源
			synchronized(this){
				if(num>0){
					System.out.println(Thread.currentThread().getName()+"吃了"+num-- +"個蘋果");
				}
			}
		}
		
	}
}

public class SynchronizedBlockDemo {
	public static void main(String[] args) {
		Runnable a = new Apple2();
		//三個執行緒表示三個人
		new Thread(a,"小A").start();
		new Thread(a,"小B").start();
		new Thread(a,"小C").start();
		
	}

}
 

方式2：同步方法:

使用synchronized修飾的方法,就叫做同步方法,保證A執行緒執行該方法的時候,其他執行緒只能在方法外等著.

Synchronized public void doWork(){

     ///TODO

}

同步鎖是誰:

      對於非static方法,同步鎖就是this.  

      對於static方法,我們使用當前方法所在類的位元組碼物件(Apple2.class).

//同步方法
class Apple3 implements Runnable{
<span style="white-space:pre">	</span>private int num = 50;
<span style="white-space:pre">	</span>public void run() {
<span style="white-space:pre">		</span>for(int i = 0; i < 50; i ++){
<span style="white-space:pre">			</span>try {
<span style="white-space:pre">				</span>doWork();
<span style="white-space:pre">			</span>} catch (InterruptedException e) {
<span style="white-space:pre">				</span>// TODO Auto-generated catch block
<span style="white-space:pre">				</span>e.printStackTrace();
<span style="white-space:pre">			</span>}
<span style="white-space:pre">		</span>}
<span style="white-space:pre">	</span>}
<span style="white-space:pre">	</span>synchronized private void doWork() throws InterruptedException {
<span style="white-space:pre">			</span>if(num>0){
<span style="white-space:pre">				</span>System.out.println(Thread.currentThread().getName()+"吃了"+num +"個蘋果");
<span style="white-space:pre">				</span>num --;
<span style="white-space:pre">				</span>Thread.sleep(10);
<span style="white-space:pre">			</span>}
<span style="white-space:pre">		</span>
<span style="white-space:pre">		</span>
<span style="white-space:pre">	</span>}
}


public class SynchronizedMethodDemo {
<span style="white-space:pre">	</span>public static void main(String[] args) {
<span style="white-space:pre">		</span>Runnable a = new Apple3();
<span style="white-space:pre">		</span>new Thread(a,"小A").start();//三個執行緒表示三個人
<span style="white-space:pre">		</span>new Thread(a,"小B").start();
<span style="white-space:pre">		</span>new Thread(a,"小C").start();
<span style="white-space:pre">		</span>
<span style="white-space:pre">	</span>}


}

注意：

不要使用synchronized修飾run方法,修飾之後,某一個執行緒就執行完了所有的功能. 好比是多個執行緒出現序列.

解決方案:把需要同步操作的程式碼定義在一個新的方法中,並且該方法使用synchronized修飾,再在run方法中呼叫該新的方法即可.

實際上，同步程式碼塊和同步方法差不了多少，在本質上是一樣的，兩者都用了一個關鍵字synchronized，synchronized保證了多執行緒併發訪問時的同步操作,避免執行緒的安全性問題，但是有一個弊端，就是使用synchronized的方法/程式碼塊的效能比不用要低一些，因此如果要用synchronized，建議儘量減小synchronized的作用域。

方式3：同步鎖（鎖機制）

Lock機制提供了比synchronized程式碼塊和synchronized方法更廣泛的鎖定操作,同步程式碼塊/同步方法具有的功能Lock都有,除此之外更強大,更體現面向物件.

//鎖機制
class Apple4 implements Runnable{
	private int num = 50;
	//建立鎖物件
	private final Lock lock = new ReentrantLock();
	public void run() {
		for(int i = 0; i < 50; i ++){
			doWork();
		}
	}
	private void doWork() {
		//進入方法，立馬加鎖
		lock.lock();//獲取鎖
		try {
			//注意：if要放到try裡，不然num為0時就不進入if中，最後鎖就釋放不了了
			if(num>0){
				System.out.println(Thread.currentThread().getName()+"吃了"+num +"個蘋果");
				num--;
				Thread.sleep(10);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			//釋放鎖
			lock.unlock();
		}
		
	}
}
public class LockDemo {
	public static void main(String[] args) {
		Runnable a = new Apple4();
		new Thread(a,"小A").start();//三個執行緒表示三個人
		new Thread(a,"小B").start();
		new Thread(a,"小C").start();
	}
}