引言

上一篇文章中我們說過，volatile通過lock指令保證了可見性、有序性以及“部分”原子性。但在大部分并發(fā)問題中，都需要保證操作的原子性，volatile并不具有該功能，這時就需要通過其他手段來達到線程安全的目的，在Java編程中，我們可以通過鎖、synchronized關(guān)鍵字，以及CAS操作來達到線程安全的目的。

synchronized

在Java的并發(fā)編程中，保證線程同步最為程序員所熟悉的就是synchronized關(guān)鍵字，synchronized關(guān)鍵字最為方便的地方是他不需要顯示的管理鎖的釋放，極大減少了編程出錯的概率。

在Java1.5及以前的版本中，synchronized并不是同步最好的選擇，由于并發(fā)時頻繁的阻塞和喚醒線程，會浪費許多資源在線程狀態(tài)的切換上，導致了synchronized的并發(fā)效率在某些情況下不如ReentrantLock。在Java1.6的版本中，對synchronized進行了許多優(yōu)化，極大的提高了synchronized的性能。只要synchronized能滿足使用環(huán)境，建議使用synchronized而不使用ReentrantLock。

synchronized的三種使用方式

1.修飾實例方法，為當前實例加鎖，進入同步方法前要獲得當前實例的鎖。

2.修飾靜態(tài)方法，為當前類對象加鎖，進入同步方法前要獲得當前類對象的鎖。

3.修飾代碼塊，指定加鎖對象，對給定對象加鎖，進入同步代碼塊前要獲得給定對象的鎖。

這三種使用方式大家應該都很熟悉，有一個要注意的地方是對靜態(tài)方法的修飾可以和實例方法的修飾同時使用，不會阻塞，因為一個是修飾的Class類，一個是修飾的實例對象。下面的例子可以說明這一點：

public class SynchronizedTest {
	public static synchronized void StaticSyncTest() {
		for (int i = 0; i < 3; i++) {
			System.out.println("StaticSyncTest");
			try {
				TimeUnit.SECONDS.sleep(1);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	public synchronized void NonStaticSyncTest() {
		for (int i = 0; i < 3; i++) {
			System.out.println("NonStaticSyncTest");
			try {
				TimeUnit.SECONDS.sleep(1);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}
public static void main(String[] args) throws InterruptedException {SynchronizedTest synchronizedTest = new SynchronizedTest();new Thread(new Runnable() {
		@Override
		public void run() {
			SynchronizedTest.StaticSyncTest();
		}
	}).start();new Thread(new Runnable() {
		@Override
		public void run() {
			synchronizedTest.NonStaticSyncTest();
		}
	}).start();
}
//StaticSyncTest
//NonStaticSyncTest
//StaticSyncTest
//NonStaticSyncTest
//StaticSyncTest
//NonStaticSyncTest 

代碼中我們開啟了兩個線程分別鎖定靜態(tài)方法和實例方法，從打印的輸出結(jié)果中我們可以看到，這兩個線程鎖定的是不同對象，可以并發(fā)執(zhí)行。

synchronized的底層原理

我們看一段synchronized關(guān)鍵字經(jīng)過編譯后的字節(jié)碼:

if (null == instance) { 
	synchronized (DoubleCheck.class) {
		if (null == instance) { 
			instance = new DoubleCheck(); 
		}
	}
} 

可以看到synchronized關(guān)鍵字在同步代碼塊前后加入了monitorenter和monitorexit這兩個指令。monitorenter指令會獲取鎖對象，如果獲取到了鎖對象，就將鎖計數(shù)器加1，未獲取到則會阻塞當前線程。monitorexit指令會釋放鎖對象，同時將鎖計數(shù)器減1。

JDK1.6對synchronized的優(yōu)化

JDK1.6對對synchronized的優(yōu)化主要體現(xiàn)在引入了“偏向鎖”和“輕量級鎖”的概念，同時synchronized的鎖只可升級，不可降級：

這里我不打算詳細講解每種鎖的實現(xiàn)，想了解的可以參照《深入理解Java虛擬機》，只簡單說下自己的理解。

偏向鎖的思想是指如果一個線程獲得了鎖，那么就從無鎖模式進入偏向模式，這一步是通過CAS操作來做的，進入偏向模式的線程每一次訪問這個鎖的同步代碼塊時都不需要再進行同步操作，除非有其他線程訪問這個鎖。

偏向鎖提高的是那些帶同步但無競爭的代碼的性能，也就是說如果你的同步代碼塊很長時間都是同一個線程訪問，偏向鎖就會提高效率，因為他減少了重復獲取鎖和釋放鎖產(chǎn)生的性能消耗。如果你的同步代碼塊會頻繁的在多個線程之間訪問，可以使用參數(shù)-XX：-UseBiasedLocking來禁止偏向鎖產(chǎn)生，避免在多個鎖狀態(tài)之間切換。

偏向鎖優(yōu)化了只有一個線程進入同步代碼塊的情況，當多個線程訪問鎖時偏向鎖就升級為了輕量級鎖。

輕量級鎖的思想是當多個線程進入同步代碼塊后，多個線程未發(fā)生競爭時一直保持輕量級鎖，通過CAS來獲取鎖。如果發(fā)生競爭，首先會采用CAS自旋操作來獲取鎖，自旋在極短時間內(nèi)發(fā)生，有固定的自旋次數(shù)，一旦自旋獲取失敗，則升級為重量級鎖。

輕量級鎖優(yōu)化了多個線程進入同步代碼塊的情況，多個線程未發(fā)生競爭時，可以通過CAS獲取鎖，減少鎖狀態(tài)切換。當多個線程發(fā)生競爭時，不是直接阻塞線程，而是通過CAS自旋來嘗試獲取鎖，減少了阻塞線程的概率，這樣就提高了synchronized鎖的性能。

synchronized的等待喚醒機制

synchronized的等待喚醒是通過notify/notifyAll和wait三個方法來實現(xiàn)的，這三個方法的執(zhí)行都必須在同步代碼塊或同步方法中進行，否則將會報錯。

wait方法的作用是使當前執(zhí)行代碼的線程進行等待，notify/notifyAll相同，都是通知等待的代碼繼續(xù)執(zhí)行，notify只通知任一個正在等待的線程，notifyAll通知所有正在等待的線程。wait方法跟sleep不一樣，他會釋放當前同步代碼塊的鎖，notify在通知任一等待的線程時不會釋放鎖，只有在當前同步代碼塊執(zhí)行完成之后才會釋放鎖。下面的代碼可以說明這一點:

public static void main(String[] args) throws InterruptedException {waitThread();notifyThread();
}
private static Object lockObject = new Object();
private static void waitThread() {Thread watiThread = new Thread(new Runnable() {@Overridepublic void run() {synchronized (lockObject) {System.out.println(Thread.currentThread().getName() + "wait-before");try {TimeUnit.SECONDS.sleep(2);lockObject.wait();} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "after-wait");}}},"waitthread");watiThread.start();
}
private static void notifyThread() {Thread watiThread = new Thread(new Runnable() {@Overridepublic void run() {synchronized (lockObject) {System.out.println(Thread.currentThread().getName() + "notify-before");lockObject.notify();try {TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) {e.printStackTrace();} System.out.println(Thread.currentThread().getName() + "after-notify");}}},"notifythread");watiThread.start();
}
//waitthreadwait-before
//notifythreadnotify-before
//notifythreadafter-notify
//waitthreadafter-wait 

代碼中notify線程通知之后wait線程并沒有馬上啟動，還需要notity線程執(zhí)行完同步代碼塊釋放鎖之后wait線程才開始執(zhí)行。

CAS

在synchronized的優(yōu)化過程中我們看到大量使用了CAS操作，CAS全稱Compare And Set（或Compare And Swap）,CAS包含三個操作數(shù)：內(nèi)存位置(V)、原值(A)、新值(B)。簡單來說CAS操作就是一個虛擬機實現(xiàn)的原子操作，這個原子操作的功能就是將舊值(A)替換為新值(B)，如果舊值(A)未被改變，則替換成功，如果舊值(A)已經(jīng)被改變則替換失敗。

可以通過AtomicInteger類的自增代碼來說明這個問題，當不使用同步時下面這段代碼很多時候不能得到預期值10000，因為noncasi[0]++不是原子操作。

private static void IntegerTest() throws InterruptedException {final Integer[] noncasi = new Integer[]{ 0 };for (int i = 0; i < 10; i++) {Thread thread = new Thread(new Runnable() {@Overridepublic void run() {for (int j = 0; j < 1000; j++) {noncasi[0]++;}}});thread.start();}while (Thread.activeCount() > 2) {Thread.sleep(10);}System.out.println(noncasi[0]);
}
//7889 

當使用AtomicInteger的getAndIncrement方法來實現(xiàn)自增之后相當于將casi.getAndIncrement()操作變成了原子操作：

private static void AtomicIntegerTest() throws InterruptedException {AtomicInteger casi = new AtomicInteger();casi.set(0);for (int i = 0; i < 10; i++) {Thread thread = new Thread(new Runnable() {@Overridepublic void run() {for (int j = 0; j < 1000; j++) {casi.getAndIncrement();}}});thread.start();}while (Thread.activeCount() > 2) {Thread.sleep(10);}System.out.println(casi.get());
}
//10000 

當然也可以通過synchronized關(guān)鍵字來達到目的，但CAS操作不需要加鎖解鎖以及切換線程狀態(tài)，效率更高。

再來看看casi.getAndIncrement()具體做了什么，在JDK1.8之前getAndIncrement是這樣實現(xiàn)的（類似incrementAndGet）:

private volatile int value;
public final int incrementAndGet() {for (;;) {int current = get();int next = current + 1;if (compareAndSet(current, next))return next;}
} 

通過compareAndSet將變量自增，如果自增成功則完成操作，如果自增不成功，則自旋進行下一次自增，由于value變量是volatile修飾的，通過volatile的可見性，每次get()都能獲取到最新值，這樣就保證了自增操作每次自旋一定次數(shù)之后一定會成功。

JDK1.8中則直接將getAndAddInt方法直接封裝成了原子性的操作，更加方便使用。

public final int getAndIncrement() {return unsafe.getAndAddInt(this, valueOffset, 1);
} 

CAS操作是實現(xiàn)Java并發(fā)包的基石，他理解起來比較簡單但同時也非常重要。Java并發(fā)包就是在CAS操作和volatile基礎(chǔ)上建立的，下圖中列舉了J.U.C包中的部分類支撐圖：

到此這篇關(guān)于Java synchronized與CAS使用方式詳解的文章就介紹到這了,更多相關(guān)Java synchronized與CAS內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論