造成線程安全問題的主要誘因有兩點，一是存在共享數據(也稱臨界資源)，二是存在多條線程共同操作共享數據。
當存在多個線程操作共享數據時，需要保證同一時刻有且只有一個線程在操作共享數據，其他線程必須等到該線程處理完數據後再進行，這種方式有個高尚的名稱叫互斥鎖，即能達到互斥訪問目的的鎖，也就是說當一個共享數據被當前正在訪問的線程加上互斥鎖後，在同一個時刻，其他線程只能處於等待的狀態，直到當前線程處理完畢釋放該鎖。在 Java 中，關鍵字 synchronized可以保證在同一個時刻，只有一個線程可以執行某個方法或者某個代碼塊(主要是對方法或者代碼塊中存在共享數據的操作)，同時我們還應該注意到synchronized另外一個重要的作用，synchronized可保證一個線程的變化(主要是共享數據的變化)被其他線程所看到（保證可見性，完全可以替代Volatile功能），這點確實也是很重要的。
synchronized的三種應用方式
修飾實例方法，作用於當前實例加鎖，進入同步代碼前要獲得當前實例的鎖
修飾靜態方法，作用於當前類對象加鎖，進入同步代碼前要獲得當前類對象的鎖
修飾代碼塊，指定加鎖對象，對給定對象加鎖，進入同步代碼庫前要獲得給定對象的鎖。
synchronized作用於實例方法
所謂的實例對象鎖就是用synchronized修飾實例對象中的實例方法，注意是實例方法不包括靜態方法，如下
package com.lxk.thread.syn;
/**
* synchronized作用於實例方法
*
* @author LiXuekai on 2020/4/29
*/
public class AccountingSync implements Runnable {
/**
* 共享資源(臨界資源)
*/
static int i = 0;
/**
* synchronized 修飾實例方法
*/
public synchronized void increase() {
i++;
}
@Override
public void run() {
for (int j = 0; j < 1000000; j++) {
increase();
}
}
/**
* 輸出結果:
* 2000000
*/
public static void main(String[] args) throws InterruptedException {
AccountingSync instance = new AccountingSync();
Thread t1 = new Thread(instance);
Thread t2 = new Thread(instance);
t1.start();
t2.start();
// join 的作用就是讓main線程稍息， t1 t2執行完之後 main 再繼續
t1.join();
t2.join();
System.out.println(i);
}
}
運行結果截圖：
上述代碼中，我們開啓兩個線程操作同一個共享資源即變量i，由於i++;操作並不具備原子性，該操作是先讀取值，然後寫回一個新值，相當於原來的值加上1，分兩步完成，如果第二個線程在第一個線程讀取舊值和寫回新值期間讀取i的域值，那麼第二個線程就會與第一個線程一起看到同一個值，並執行相同值的加1操作，這也就造成了線程安全失敗，因此對於increase方法必須使用synchronized修飾，以便保證線程安全。此時我們應該注意到synchronized修飾的是實例方法increase，在這樣的情況下，當前線程的鎖便是實例對象instance，注意Java中的線程同步鎖可以是任意對象。從代碼執行結果來看確實是正確的，倘若我們沒有使用synchronized關鍵字，其最終輸出結果就很可能小於2000000，這便是synchronized關鍵字的作用。這裏我們還需要意識到，當一個線程正在訪問一個對象的 synchronized 實例方法，那麼其他線程不能訪問該對象的其他 synchronized 方法，畢竟一個對象只有一把鎖，當一個線程獲取了該對象的鎖之後，其他線程無法獲取該對象的鎖，所以無法訪問該對象的其他synchronized實例方法，但是其他線程還是可以訪問該實例對象的其他非synchronized方法，當然如果是一個線程 A 需要訪問實例對象 obj1 的 synchronized 方法 f1(當前對象鎖是obj1)，另一個線程 B 需要訪問實例對象 obj2 的 synchronized 方法 f2(當前對象鎖是obj2)，這樣是允許的，因爲兩個實例對象鎖並不同相同，此時如果兩個線程操作數據並非共享的，線程安全是有保障的，遺憾的是如果兩個線程操作的是共享數據，那麼線程安全就有可能無法保證了，如下代碼將演示出該現象
package com.lxk.thread.syn;
/**
* @author LiXuekai on 2020/4/29
*/
public class AccountingSyncBad implements Runnable {
static int i = 0;
public synchronized void increase() {
i++;
}
@Override
public void run() {
for (int j = 0; j < 1000000; j++) {
increase();
}
}
public static void main(String[] args) throws InterruptedException {
//new新實例
Thread t1 = new Thread(new AccountingSyncBad());
//new新實例
Thread t2 = new Thread(new AccountingSyncBad());
t1.start();
t2.start();
// join 的作用就是讓main線程稍息， t1 t2執行完之後 main 再繼續
t1.join();
t2.join();
System.out.println(i);
}
}
代碼運行結果：
上述代碼與前面不同的是我們同時創建了兩個新實例AccountingSyncBad，然後啓動兩個不同的線程對共享變量i進行操作，但很遺憾操作結果是1707154而不是期望結果2000000，因爲上述代碼犯了嚴重的錯誤，雖然我們使用synchronized修飾了increase方法，但卻new了兩個不同的實例對象，這也就意味着存在着兩個不同的實例對象鎖，因此t1和t2都會進入各自的對象鎖，也就是說t1和t2線程使用的是不同的鎖，因此線程安全是無法保證的。解決這種困境的的方式是將synchronized作用於靜態的increase方法，這樣的話，對象鎖就當前類對象，由於無論創建多少個實例對象，但對於的類對象擁有隻有一個，所有在這樣的情況下對象鎖就是唯一的。下面我們看看如何使用將synchronized作用於靜態的increase方法。
synchronized作用於靜態方法
當synchronized作用於靜態方法時，其鎖就是當前類的class對象鎖。由於靜態成員不專屬於任何一個實例對象，是類成員，因此通過class對象鎖可以控制靜態 成員的併發操作。需要注意的是如果一個線程A調用一個實例對象的非static synchronized方法，而線程B需要調用這個實例對象所屬類的靜態 synchronized方法，是允許的，不會發生互斥現象，因爲訪問靜態 synchronized 方法佔用的鎖是當前類的class對象，而訪問非靜態 synchronized 方法佔用的鎖是當前實例對象鎖，看如下代碼
package com.lxk.thread.syn;
/**
* synchronized作用於靜態方法
* 當synchronized作用於靜態方法時，其鎖就是當前類的class對象鎖
*
* @author LiXuekai on 2020/4/29
*/
public class AccountingSyncClass implements Runnable {
static int i = 0;
/**
* 作用於靜態方法,鎖是當前class對象,也就是
* AccountingSyncClass類對應的class對象
*/
public static synchronized void increase() {
i++;
}
/**
* 非靜態,訪問時鎖不一樣不會發生互斥
*/
public synchronized void increase4Obj() {
i++;
}
@Override
public void run() {
for (int j = 0; j < 1000000; j++) {
increase();
}
}
public static void main(String[] args) throws InterruptedException {
//new新實例
Thread t1 = new Thread(new AccountingSyncClass());
//new新實例
Thread t2 = new Thread(new AccountingSyncClass());
//啓動線程
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(i);
}
}
運行結果截圖：
由於synchronized關鍵字修飾的是靜態increase方法，與修飾實例方法不同的是，其鎖對象是當前類的class對象。注意代碼中的increase4Obj方法是實例方法，其對象鎖是當前實例對象，如果別的線程調用該方法，將不會產生互斥現象，畢竟鎖對象不同，但我們應該意識到這種情況下可能會發現線程安全問題(操作了共享靜態變量i)。
synchronized同步代碼塊
除了使用關鍵字修飾實例方法和靜態方法外，還可以使用同步代碼塊，在某些情況下，我們編寫的方法體可能比較大，同時存在一些比較耗時的操作，而需要同步的代碼又只有一小部分，如果直接對整個方法進行同步操作，可能會得不償失，此時我們可以使用同步代碼塊的方式對需要同步的代碼進行包裹，這樣就無需對整個方法進行同步操作了，同步代碼塊的使用示例如下：
package com.lxk.thread.syn;
/**
* synchronized同步代碼塊
*
* @author LiXuekai on 2020/4/29
*/
public class AccountingSyncCode implements Runnable {
private static final AccountingSyncCode instance = new AccountingSyncCode();
static int i = 0;
@Override
public void run() {
//省略其他耗時操作....
//使用同步代碼塊對變量i進行同步操作,鎖對象爲instance
synchronized (instance) {
for (int j = 0; j < 1000000; j++) {
i++;
}
}
}
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(instance);
Thread t2 = new Thread(instance);
t1.start();
t2.start();
// join 的作用就是讓main線程稍息， t1 t2執行完之後 main 再繼續
t1.join();
t2.join();
System.out.println(i);
}
}
從代碼看出，將synchronized作用於一個給定的實例對象instance，即當前實例對象就是鎖對象，每次當線程進入synchronized包裹的代碼塊時就會要求當前線程持有instance實例對象鎖，如果當前有其他線程正持有該對象鎖，那麼新到的線程就必須等待，這樣也就保證了每次只有一個線程執行i++;操作。
Java虛擬機對synchronized的優化
鎖的狀態總共有四種，無鎖狀態、偏向鎖、輕量級鎖和重量級鎖。隨着鎖的競爭，鎖可以從偏向鎖升級到輕量級鎖，再升級的重量級鎖，但是鎖的升級是單向的，也就是說只能從低到高升級，不會出現鎖的降級，關於重量級鎖，前面我們已詳細分析過，下面我們將介紹偏向鎖和輕量級鎖以及JVM的其他優化手段，這裏並不打算深入到每個鎖的實現和轉換過程更多地是闡述Java虛擬機所提供的每個鎖的核心優化思想，畢竟涉及到具體過程比較繁瑣，如需瞭解詳細過程可以查閱《深入理解Java虛擬機原理》。
偏向鎖
偏向鎖是Java 6之後加入的新鎖，它是一種針對加鎖操作的優化手段，經過研究發現，在大多數情況下，鎖不僅不存在多線程競爭，而且總是由同一線程多次獲得，因此爲了減少同一線程獲取鎖(會涉及到一些CAS操作,耗時)的代價而引入偏向鎖。偏向鎖的核心思想是，如果一個線程獲得了鎖，那麼鎖就進入偏向模式，此時Mark Word 的結構也變爲偏向鎖結構，當這個線程再次請求鎖時，無需再做任何同步操作，即獲取鎖的過程，這樣就省去了大量有關鎖申請的操作，從而也就提供程序的性能。所以，對於沒有鎖競爭的場合，偏向鎖有很好的優化效果，畢竟極有可能連續多次是同一個線程申請相同的鎖。但是對於鎖競爭比較激烈的場合，偏向鎖就失效了，因爲這樣場合極有可能每次申請鎖的線程都是不相同的，因此這種場合下不應該使用偏向鎖，否則會得不償失，需要注意的是，偏向鎖失敗後，並不會立即膨脹爲重量級鎖，而是先升級爲輕量級鎖。下面我們接着瞭解輕量級鎖。
輕量級鎖
倘若偏向鎖失敗，虛擬機並不會立即升級爲重量級鎖，它還會嘗試使用一種稱爲輕量級鎖的優化手段(1.6之後加入的)，此時Mark Word 的結構也變爲輕量級鎖的結構。輕量級鎖能夠提升程序性能的依據是“對絕大部分的鎖，在整個同步週期內都不存在競爭”，注意這是經驗數據。需要了解的是，輕量級鎖所適應的場景是線程交替執行同步塊的場合，如果存在同一時間訪問同一鎖的場合，就會導致輕量級鎖膨脹爲重量級鎖。
自旋鎖
輕量級鎖失敗後，虛擬機爲了避免線程真實地在操作系統層面掛起，還會進行一項稱爲自旋鎖的優化手段。這是基於在大多數情況下，線程持有鎖的時間都不會太長，如果直接掛起操作系統層面的線程可能會得不償失，畢竟操作系統實現線程之間的切換時需要從用戶態轉換到核心態，這個狀態之間的轉換需要相對比較長的時間，時間成本相對較高，因此自旋鎖會假設在不久將來，當前的線程可以獲得鎖，因此虛擬機會讓當前想要獲取鎖的線程做幾個空循環(這也是稱爲自旋的原因)，一般不會太久，可能是50個循環或100循環，在經過若干次循環後，如果得到鎖，就順利進入臨界區。如果還不能獲得鎖，那就會將線程在操作系統層面掛起，這就是自旋鎖的優化方式，這種方式確實也是可以提升效率的。最後沒辦法也就只能升級爲重量級鎖了。
synchronized的可重入性
從互斥鎖的設計上來說，當一個線程試圖操作一個由其他線程持有的對象鎖的臨界資源時，將會處於阻塞狀態，但當一個線程再次請求自己持有對象鎖的臨界資源時，這種情況屬於重入鎖，請求將會成功，在java中synchronized是基於原子性的內部鎖機制，是可重入的，因此在一個線程調用synchronized方法的同時在其方法體內部調用該對象另一個synchronized方法，也就是說一個線程得到一個對象鎖後再次請求該對象鎖，是允許的，這就是synchronized的可重入性。如下：
package com.lxk.thread.syn;
/**
* synchronized 的可重入性
*
* @author LiXuekai on 2020/4/30
*/
public class AccountingSyncRe implements Runnable {
private static AccountingSyncRe instance = new AccountingSyncRe();
private static int i = 0;
private static int j = 0;
@Override
public void run() {
for (int j = 0; j < 1000000; j++) {
//this,當前實例對象鎖
synchronized (this) {
i++;
//synchronized的可重入性
increase();
}
}
}
private synchronized void increase() {
j++;
}
/**
* java中synchronized是基於原子性的內部鎖機制，是可重入的
*/
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(instance);
Thread t2 = new Thread(instance);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(i);
System.out.println(j);
}
// 正如代碼所演示的，在獲取當前實例對象鎖後進入synchronized代碼塊執行同步代碼，
// 並在代碼塊中調用了當前實例對象的另外一個synchronized方法，再次請求當前實例鎖時，將被允許，進而執行方法體代碼，這就是重入鎖最直接的體現，
// 需要特別注意另外一種情況，當子類繼承父類時，子類也是可以通過可重入鎖調用父類的同步方法。注意由於synchronized是基於monitor實現的，
// 因此每次重入，monitor中的計數器仍會加1。
}