引言
上一篇文章中我們說過，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 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
複製程式碼程式碼中我們開啟了兩個執行緒分別鎖定靜態方法和例項方法，從列印的輸出結果中我們可以看到，這兩個執行緒鎖定的是不同物件，可以併發執行。
synchronized的底層原理
我們看一段synchronized關鍵字經過編譯後的位元組碼:
if (null == instance) {
synchronized (DoubleCheck.class) {
if (null == instance) {
instance = new DoubleCheck();
}
}
}
複製程式碼
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 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
複製程式碼程式碼中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包中的部分類支撐圖：
