Java並發（4）- synchronized與CAS
引言
上一篇文章中我們說過，volatile通過lock指令保證了可見性、有序性以及“部分”原子性。但在大部分並發問題中，都需要保證操作的原子性，volatile並不具有該功能，這時就需要通過其他手段來達到線程安全的目的，在Java編程中，我們可以通過鎖、synchronized關鍵字，以及CAS操作來達到線程安全的目的。
synchronized
在Java的並發編程中，保證線程同步最為程序員所熟悉的就是synchronized關鍵字，synchronized關鍵字最為方便的地方是他不需要顯示的管理鎖的釋放，極大減少了編程出錯的概率。
在Java1.5及以前的版本中，synchronized並不是同步最好的選擇，由於並發時頻繁的阻塞和喚醒線程，會浪費許多資源在線程狀態的切換上，導致了synchronized的並發效率在某些情況下不如ReentrantLock。在Java1.6的版本中，對synchronized進行了許多優化，極大的提高了synchronized的性能。只要synchronized能滿足使用環境，建議使用synchronized而不使用ReentrantLock。
synchronized的三種使用方式
- 修飾實例方法，為當前實例加鎖，進入同步方法前要獲得當前實例的鎖。
- 修飾靜態方法，為當前類對象加鎖，進入同步方法前要獲得當前類對象的鎖。
- 修飾代碼塊，指定加鎖對象，對給定對象加鎖，進入同步代碼塊前要獲得給定對象的鎖。
這三種使用方式大家應該都很熟悉，有一個要註意的地方是對靜態方法的修飾可以和實例方法的修飾同時使用，不會阻塞，因為一個是修飾的Class類，一個是修飾的實例對象。下面的例子可以說明這一點：
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() { @Override public 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() { @Override public 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
代碼中我們開啟了兩個線程分別鎖定靜態方法和實例方法，從打印的輸出結果中我們可以看到，這兩個線程鎖定的是不同對象，可以並發執行。
synchronized的底層原理
我們看一段synchronized關鍵字經過編譯後的字節碼:
if (null == instance) {
synchronized (DoubleCheck.class) {
if (null == instance) {
instance = new DoubleCheck();
}
}
}
可以看到synchronized關鍵字在同步代碼塊前後加入了monitorenter和monitorexit這兩個指令。monitorenter指令會獲取鎖對象，如果獲取到了鎖對象，就將鎖計數器加1，未獲取到則會阻塞當前線程。monitorexit指令會釋放鎖對象，同時將鎖計數器減1。
JDK1.6對synchronized的優化
JDK1.6對對synchronized的優化主要體現在引入了“偏向鎖”和“輕量級鎖”的概念，同時synchronized的鎖只可升級，不可降級：
這裏我不打算詳細講解每種鎖的實現，想了解的可以參照《深入理解Java虛擬機》，只簡單說下自己的理解。
偏向鎖的思想是指如果一個線程獲得了鎖，那麽就從無鎖模式進入偏向模式，這一步是通過CAS操作來做的，進入偏向模式的線程每一次訪問這個鎖的同步代碼塊時都不需要再進行同步操作，除非有其他線程訪問這個鎖。
偏向鎖提高的是那些帶同步但無競爭的代碼的性能，也就是說如果你的同步代碼塊很長時間都是同一個線程訪問，偏向鎖就會提高效率，因為他減少了重復獲取鎖和釋放鎖產生的性能消耗。如果你的同步代碼塊會頻繁的在多個線程之間訪問，可以使用參數-XX：-UseBiasedLocking來禁止偏向鎖產生，避免在多個鎖狀態之間切換。
偏向鎖優化了只有一個線程進入同步代碼塊的情況，當多個線程訪問鎖時偏向鎖就升級為了輕量級鎖。
輕量級鎖的思想是當多個線程進入同步代碼塊後，多個線程未發生競爭時一直保持輕量級鎖，通過CAS來獲取鎖。如果發生競爭，首先會采用CAS自旋操作來獲取鎖，自旋在極短時間內發生，有固定的自旋次數，一旦自旋獲取失敗，則升級為重量級鎖。
輕量級鎖優化了多個線程進入同步代碼塊的情況，多個線程未發生競爭時，可以通過CAS獲取鎖，減少鎖狀態切換。當多個線程發生競爭時，不是直接阻塞線程，而是通過CAS自旋來嘗試獲取鎖，減少了阻塞線程的概率，這樣就提高了synchronized鎖的性能。
synchronized的等待喚醒機制
synchronized的等待喚醒是通過notify/notifyAll和wait三個方法來實現的，這三個方法的執行都必須在同步代碼塊或同步方法中進行，否則將會報錯。
wait方法的作用是使當前執行代碼的線程進行等待，notify/notifyAll相同，都是通知等待的代碼繼續執行，notify只通知任一個正在等待的線程，notifyAll通知所有正在等待的線程。wait方法跟sleep不一樣，他會釋放當前同步代碼塊的鎖，notify在通知任一等待的線程時不會釋放鎖，只有在當前同步代碼塊執行完成之後才會釋放鎖。下面的代碼可以說明這一點:
public class SynchronizedTest {
public static synchronized void StaticSyncTest() {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
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();
}
}
}
});
thread.start();
}
public synchronized void NonStaticSyncTest() {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
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();
}
}
}
});
thread.start();
}
}
public static void main(String[] args) throws InterruptedException {
SynchronizedTest synchronizedTest = new SynchronizedTest();
SynchronizedTest.StaticSyncTest();
synchronizedTest.NonStaticSyncTest();
}
//StaticSyncTest
//NonStaticSyncTest
//StaticSyncTest
//NonStaticSyncTest
//StaticSyncTest
//NonStaticSyncTest代碼中notify線程通知之後wait線程並沒有馬上啟動，還需要notity線程執行完同步代碼塊釋放鎖之後wait線程才開始執行。
CAS
在synchronized的優化過程中我們看到大量使用了CAS操作，CAS全稱Compare And Set（或Compare And Swap）,CAS包含三個操作數：內存位置(V)、原值(A)、新值(B)。簡單來說CAS操作就是一個虛擬機實現的原子操作，這個原子操作的功能就是將舊值(A)替換為新值(B)，如果舊值(A)未被改變，則替換成功，如果舊值(A)已經被改變則替換失敗。
可以通過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() {
@Override
public 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方法來實現自增之後相當於將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() {
@Override
public 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關鍵字來達到目的，但CAS操作不需要加鎖解鎖以及切換線程狀態，效率更高。
再來看看casi.getAndIncrement()具體做了什麽，在JDK1.8之前getAndIncrement是這樣實現的（類似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()都能獲取到最新值，這樣就保證了自增操作每次自旋一定次數之後一定會成功。
JDK1.8中則直接將getAndAddInt方法直接封裝成了原子性的操作，更加方便使用。
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
}CAS操作是實現Java並發包的基石，他理解起來比較簡單但同時也非常重要。Java並發包就是在CAS操作和volatile基礎上建立的，下圖中列舉了J.U.C包中的部分類支撐圖：
Java並發（4）- synchronized與CAS