Java之戳中痛點 - （8）synchronized深度解析

Java之戳中痛點 - （8）synchronized深度解析
概覽：
簡介：作用、地位、不控制併發的影響
用法：對象鎖和類鎖
多線程訪問同步方法的7種情況
性質：可重入、不可中斷
原理：加解鎖原理、可重入原理、可見性原理
缺陷：效率低、不夠靈活、無法預判是否成功獲取到鎖
如何選擇Lock或Synchronized
如何提高性能、JVM如何決定哪個線程獲取鎖
總結
後續會有代碼演示，測試環境 JDK8、IDEA
一、簡介
1、作用
能夠保證在==同一時刻==最多隻有一個線程執行該代碼，以保證併發安全的效果。

2、地位
Synchronized是Java關鍵字，Java原生支持
最基本的互斥同步手段
併發編程的元老級別
3、不控制併發的影響
測試：兩個線程同時a++，猜一下結果

package cn.jsonshare.java.base.synchronizedtest;

/**

不使用synchronized,兩個線程同時a++
*
@author JSON
@date 2019-08-29
*/

public class SynchronizedTest1 implements Runnable{

static SynchronizedTest1 st = new SynchronizedTest1();

static int a = 0;

/**
 * 不使用synchronized,兩個線程同時a++
 */
public static void main(String[] args) throws Exception{
    Thread t1 = new Thread(st);
    Thread t2 = new Thread(st);
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    System.out.println(a);
}

@Override
public void run(){
    for(int i=0; i<10000; i++){
        a++;
    }
}

}

預期是20000，但多次執行的結果都小於20000

10108
11526
10736
...
二、用法：對象鎖和類鎖
1、對象鎖
代碼塊形式：手動指定鎖對象
方法鎖形式：synchronized修飾方法，鎖對象默認爲this
package cn.jsonshare.java.base.synchronizedtest;

/**

對象鎖實例: 代碼塊形式
*
@author JSON
@date 2019-08-29
*/

public class SynchronizedTest2 implements Runnable{

static SynchronizedTest2 st = new SynchronizedTest2();

public static void main(String[] args) {
    Thread t1 = new Thread(st);
    Thread t2 = new Thread(st);
    t1.start();
    t2.start();
    while(t1.isAlive() || t2.isAlive()){

    }
    System.out.println("run over");

}

@Override
public void run(){
    synchronized (this){
        System.out.println("開始執行:" + Thread.currentThread().getName());
        try {
            // 模擬執行內容
            Thread.sleep(3000);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println("執行結束:" + Thread.currentThread().getName());
    }
}

}
package cn.jsonshare.java.base.synchronizedtest;

/**

對象鎖實例：synchronized方法
@author JSON
@date 2019-08-29
*/

public class SynchronizedTest3 implements Runnable{

static SynchronizedTest3 st = new SynchronizedTest3();

public static void main(String[] args) throws Exception{
    Thread t1 = new Thread(st);
    Thread t2 = new Thread(st);
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    System.out.println("run over");
}

@Override
public void run(){
    method();
}

public synchronized void method(){
    System.out.println("開始執行:" + Thread.currentThread().getName());
    try {
        // 模擬執行內容
        Thread.sleep(3000);
    }catch (Exception e){
        e.printStackTrace();
    }
    System.out.println("執行結束:" + Thread.currentThread().getName());
}

}
結果：

開始執行:Thread-0
執行結束:Thread-0
開始執行:Thread-1
執行結束:Thread-1
run over
2、類鎖
==概念：Java類可能有多個對象，但只有一個Class對象==

==本質：所謂的類鎖，不過是Class對象的鎖而已==

==用法和效果：類鎖只能在同一時刻被一個對象擁有==

形式1：synchronized加載static方法上

形式2：synchronized(*.class)代碼塊

package cn.jsonshare.java.base.synchronizedtest;

/**

類鎖：synchronized加載static方法上
*
@author JSON
@date 2019-08-29
*/

public class SynchronizedTest4 implements Runnable{

static SynchronizedTest4 st1 = new SynchronizedTest4();
static SynchronizedTest4 st2 = new SynchronizedTest4();

public static void main(String[] args) throws Exception{
    Thread t1 = new Thread(st1);
    Thread t2 = new Thread(st2);
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    System.out.println("run over");
}

@Override
public void run(){
    method();
}

public static synchronized void method(){
    System.out.println("開始執行:" + Thread.currentThread().getName());
    try {
        // 模擬執行內容
        Thread.sleep(3000);
    }catch (Exception e){
        e.printStackTrace();
    }
    System.out.println("執行結束:" + Thread.currentThread().getName());
}

}

package cn.jsonshare.java.base.synchronizedtest;

/**

類鎖：synchronized(*.class)代碼塊
*
@author JSON
@date 2019-08-29
*/

public class SynchronizedTest5 implements Runnable{

static SynchronizedTest4 st1 = new SynchronizedTest4();
static SynchronizedTest4 st2 = new SynchronizedTest4();

public static void main(String[] args) throws Exception{
    Thread t1 = new Thread(st1);
    Thread t2 = new Thread(st2);
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    System.out.println("run over");
}

@Override
public void run(){
    method();
}

public void method(){
    synchronized(SynchronizedTest5.class){
        System.out.println("開始執行:" + Thread.currentThread().getName());
        try {
            // 模擬執行內容
            Thread.sleep(3000);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println("執行結束:" + Thread.currentThread().getName());
    }
}

}
結果：

開始執行:Thread-0
執行結束:Thread-0
開始執行:Thread-1
執行結束:Thread-1
run over
三、多線程訪問同步方法的7種情況
兩個線程同時訪問一個對象的相同的synchronized方法
兩個線程同時訪問兩個對象的相同的synchronized方法
兩個線程同時訪問兩個對象的相同的static的synchronized方法
兩個線程同時訪問同一對象的synchronized方法與非synchronized方法
兩個線程訪問同一對象的不同的synchronized方法
兩個線程同時訪問同一對象的static的synchronized方法與非static的synchronized方法
方法拋出異常後，會釋放鎖嗎
仔細看下面示例代碼結果輸出的結果，注意輸出時間間隔，來預測結論

場景1：

package cn.jsonshare.java.base.synchronizedtest;

/**

兩個線程同時訪問一個對象的相同的synchronized方法
*
@author JSON
@date 2019-08-29
*/

public class SynchronizedScene1 implements Runnable{

static SynchronizedScene1 ss = new SynchronizedScene1();

public static void main(String[] args) throws Exception{
    Thread t1 = new Thread(ss);
    Thread t2 = new Thread(ss);
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    System.out.println("run over");
}

@Override
public void run(){
    method();
}

public synchronized void method(){
    System.out.println("開始執行:" + Thread.currentThread().getName());
    try {
        // 模擬執行內容
        Thread.sleep(3000);
    }catch (Exception e){
        e.printStackTrace();
    }
    System.out.println("執行結束:" + Thread.currentThread().getName());
}

}
場景2：

package cn.jsonshare.java.base.synchronizedtest;

/**

兩個線程同時訪問兩個對象的相同的synchronized方法
*
@author JSON
@date 2019-08-29
*/

public class SynchronizedScene2 implements Runnable{

static SynchronizedScene2 ss1 = new SynchronizedScene2();
static SynchronizedScene2 ss2 = new SynchronizedScene2();

public static void main(String[] args) throws Exception{
    Thread t1 = new Thread(ss1);
    Thread t2 = new Thread(ss2);
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    System.out.println("run over");
}

@Override
public void run(){
    method();
}

public synchronized void method(){
    System.out.println("開始執行:" + Thread.currentThread().getName());
    try {
        // 模擬執行內容
        Thread.sleep(3000);
    }catch (Exception e){
        e.printStackTrace();
    }
    System.out.println("執行結束:" + Thread.currentThread().getName());
}

}
場景3：

package cn.jsonshare.java.base.synchronizedtest;

/**

兩個線程同時訪問兩個對象的相同的static的synchronized方法
*
@author JSON
@date 2019-08-29
*/

public class SynchronizedScene3 implements Runnable{

static SynchronizedScene3 ss1 = new SynchronizedScene3();
static SynchronizedScene3 ss2 = new SynchronizedScene3();

public static void main(String[] args) throws Exception{
    Thread t1 = new Thread(ss1);
    Thread t2 = new Thread(ss2);
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    System.out.println("run over");
}

@Override
public void run(){
    method();
}

public synchronized static void method(){
    System.out.println("開始執行:" + Thread.currentThread().getName());
    try {
        // 模擬執行內容
        Thread.sleep(3000);
    }catch (Exception e){
        e.printStackTrace();
    }
    System.out.println("執行結束:" + Thread.currentThread().getName());
}

}
場景4：

package cn.jsonshare.java.base.synchronizedtest;

/**

兩個線程同時訪問同一對象的synchronized方法與非synchronized方法
*
@author JSON
@date 2019-08-29
*/

public class SynchronizedScene4 implements Runnable{

static SynchronizedScene4 ss1 = new SynchronizedScene4();

public static void main(String[] args) throws Exception{
    Thread t1 = new Thread(ss1);
    Thread t2 = new Thread(ss1);
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    System.out.println("run over");
}

@Override
public void run(){
    // 模擬兩個線程同時訪問 synchronized方法與非synchronized方法
    if(Thread.currentThread().getName().equals("Thread-0")){
        method1();
    }else{
        method2();
    }
}

public void method1(){
    System.out.println("method1開始執行:" + Thread.currentThread().getName());
    try {
        // 模擬執行內容
        Thread.sleep(3000);
    }catch (Exception e){
        e.printStackTrace();
    }
    System.out.println("method1執行結束:" + Thread.currentThread().getName());
}

public synchronized void method2(){
    System.out.println("method2開始執行:" + Thread.currentThread().getName());
    try {
        // 模擬執行內容
        Thread.sleep(3000);
    }catch (Exception e){
        e.printStackTrace();
    }
    System.out.println("method2執行結束:" + Thread.currentThread().getName());
}

}
場景5：

package cn.jsonshare.java.base.synchronizedtest;

/**

兩個線程訪問同一對象的不同的synchronized方法
*
@author JSON
@date 2019-08-29
*/

public class SynchronizedScene5 implements Runnable{

static SynchronizedScene5 ss1 = new SynchronizedScene5();

public static void main(String[] args) throws Exception{
    Thread t1 = new Thread(ss1);
    Thread t2 = new Thread(ss1);
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    System.out.println("run over");
}

@Override
public void run(){
    // 模擬兩個線程同時訪問不同的synchronized方法
    if(Thread.currentThread().getName().equals("Thread-0")){
        method1();
    }else{
        method2();
    }
}

public synchronized void method1(){
    System.out.println("method1開始執行:" + Thread.currentThread().getName());
    try {
        // 模擬執行內容
        Thread.sleep(3000);
    }catch (Exception e){
        e.printStackTrace();
    }
    System.out.println("method1執行結束:" + Thread.currentThread().getName());
}

public synchronized void method2(){
    System.out.println("method2開始執行:" + Thread.currentThread().getName());
    try {
        // 模擬執行內容
        Thread.sleep(3000);
    }catch (Exception e){
        e.printStackTrace();
    }
    System.out.println("method2執行結束:" + Thread.currentThread().getName());
}

}
場景6：

package cn.jsonshare.java.base.synchronizedtest;

/**

兩個線程同時訪問同一對象的static的synchronized方法與非static的synchronized方法
*
@author JSON
@date 2019-08-29
*/

public class SynchronizedScene6 implements Runnable{

static SynchronizedScene6 ss1 = new SynchronizedScene6();

public static void main(String[] args) throws Exception{
    Thread t1 = new Thread(ss1);
    Thread t2 = new Thread(ss1);
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    System.out.println("run over");
}

@Override
public void run(){
    // 模擬兩個線程同時訪問static的synchronized方法與非static的synchronized方法
    if(Thread.currentThread().getName().equals("Thread-0")){
        method1();
    }else{
        method2();
    }
}

public static synchronized void method1(){
    System.out.println("method1開始執行:" + Thread.currentThread().getName());
    try {
        // 模擬執行內容
        Thread.sleep(3000);
    }catch (Exception e){
        e.printStackTrace();
    }
    System.out.println("method1執行結束:" + Thread.currentThread().getName());
}

public synchronized void method2(){
    System.out.println("method2開始執行:" + Thread.currentThread().getName());
    try {
        // 模擬執行內容
        Thread.sleep(3000);
    }catch (Exception e){
        e.printStackTrace();
    }
    System.out.println("method2執行結束:" + Thread.currentThread().getName());
}

}
場景7：

package cn.jsonshare.java.base.synchronizedtest;

/**

方法拋出異常後，會釋放鎖嗎
*
@author JSON
@date 2019-08-29
*/

public class SynchronizedScene7 implements Runnable{

static SynchronizedScene7 ss1 = new SynchronizedScene7();

public static void main(String[] args) throws Exception{
    Thread t1 = new Thread(ss1);
    Thread t2 = new Thread(ss1);
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    System.out.println("run over");
}

@Override
public void run(){
    method1();
}

public synchronized void method1(){
    System.out.println("method1開始執行:" + Thread.currentThread().getName());
    try {
        // 模擬執行內容
        Thread.sleep(3000);
    }catch (Exception e){
        e.printStackTrace();
    }
    // 模擬異常
    throw new RuntimeException();
    //System.out.println("method1執行結束:" + Thread.currentThread().getName());
}

}
總結：
1、兩個線程同時訪問一個對象的相同的synchronized方法

同一實例擁有同一把鎖，其他線程必然等待，順序執行
2、兩個線程同時訪問兩個對象的相同的synchronized方法

不同的實例擁有的鎖是不同的，所以不影響，並行執行
3、兩個線程同時訪問兩個對象的相同的static的synchronized方法

靜態同步方法，是類鎖，所有實例是同一把鎖，其他線程必然等待，順序執行
4、兩個線程同時訪問同一對象的synchronized方法與非synchronized方法

非synchronized方法不受影響，並行執行
5、兩個線程訪問同一對象的不同的synchronized方法

同一實例擁有同一把鎖，所以順序執行（說明：鎖的是this對象==同一把鎖）
6、兩個線程同時訪問同一對象的static的synchronized方法與非static的synchronized方法

static同步方法是類鎖，非static是對象鎖，原理上是不同的鎖，所以不受影響，並行執行
7、方法拋出異常後，會釋放鎖嗎

會自動釋放鎖，這裏區別Lock，Lock需要顯示的釋放鎖
3個核心思想：
1、一把鎖只能同時被一個線程獲取，沒有拿到鎖的線程必須等待（對應1、5的情景）

2、每個實例都對應有自己的一把鎖，不同的實例之間互不影響；

例外：鎖對象是*.class以及synchronized被static修飾的時候，所有對象共用同一把鎖（對應2、3、4、6情景）
3、無論是方法正常執行完畢還是方法拋出異常，都會釋放鎖（對應7情景）

補充：
問題：目前進入到被synchronized修飾的方法，這個方法裏邊調用了非synchronized方法，是線程安全的嗎？

package cn.jsonshare.java.base.synchronizedtest;

/**

目前進入到被synchronized修飾的方法，這個方法裏邊調用了非synchronized方法，是線程安全的嗎？
*
@author JSON
@date 2019-08-29
*/

public class SynchronizedScene8 {

public static void main(String[] args) {
    new Thread(() -> {
        method1();
    }).start();

    new Thread(() -> {
        method1();
    }).start();
}

public static synchronized void method1() {
    method2();
}

private static void method2() {
    System.out.println(Thread.currentThread().getName() + "進入非Synchronized方法");
    try {
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    System.out.println(Thread.currentThread().getName() + "結束非Synchronized方法");
}

}
結論：這樣是線程安全的

四、性質
1、可重入
指的是同一線程的外層函數獲取鎖之後，內層函數可以直接再次獲取該鎖

Java典型的可重入鎖：synchronized、ReentrantLock

好處：避免死鎖，提升封裝性

粒度：線程而非調用

情況1：證明同一方法是可重入的
情況2：證明可重入不要求是同一方法
情況3：證明可重入不要求是同一類中的
2、不可中斷
一旦這個鎖被別的線程獲取了，如果我現在想獲得，我只能選擇等待或者阻塞，直到別的線程釋放這個鎖，如果別的線程永遠不釋放鎖，那麼我只能永遠的等待下去。

相比之下，Lock類可以擁有中斷的能力，第一點：如果我覺得我等待的時間太長了，有權中斷現在已經獲取到鎖的線程執行；第二點：如果我覺得我等待的時間太長了不想再等了，也可以退出。

五、原理
1、加解鎖原理（現象、時機、深入JVM看字節碼）
現象：每一個類的實例對應一把鎖，每一個synchronized方法都必須首先獲得調用該方法的類的實例的鎖，方能執行，否則就會阻塞，方法執行完成或者拋出異常，鎖被釋放，被阻塞線程才能獲取到該鎖，執行。

獲取和釋放鎖的時機：內置鎖或監視器鎖

package cn.jsonshare.java.base.synchronizedtest;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**

method1 等價於 method2
*
@author JSON
@date 2019-08-29
*/

public class SynchronizedToLock1 {

Lock lock = new ReentrantLock();

public synchronized void method1(){
    System.out.println("執行method1");
}

public void method2(){
    lock.lock();
    try {
        System.out.println("執行method2");
    }catch (Exception e){
        e.printStackTrace();
    }finally {
        lock.unlock();
    }
}

public static void main(String[] args) {
    SynchronizedToLock1 sl = new SynchronizedToLock1();

    // method1 等價於 method2
    sl.method1();
    sl.method2();
}

}
深入JVM看字節碼：

...
monitorenter指令
...
monitorexit指令
...
2、可重入原理（加鎖次數計數器）
JVM負責跟蹤對象被加鎖的次數

線程第一次給對象加鎖的時候，計數變爲1，每當這個相同的線程在此對象上再次獲得鎖時，計數會遞增

每當任務離開時，計數遞減，當計數爲0的時候，鎖被完全釋放

3、可見性原理（內存模型）
Java內存模型

avatar

線程A向線程B發送數據的過程（JMM控制）

avatar

==synchronized關鍵字實現可見性：==

被synchronized修飾，那麼執行完成後，對對象所做的任何修改都要在釋放鎖之前，都要從線程內存寫入到主內存，所以主內存中的數據是最新的。

六、缺陷
1、效率低
1)、鎖的釋放情況少（線程執行完成或者異常情況釋放）

2)、試圖獲得鎖時不能設定超時（只能等待）

3)、不能中斷一個正在試圖獲得鎖的線程（不能中斷）

2、不夠靈活
加鎖和釋放的時機比較單一，每個鎖僅有單一的條件（某個對象），可能是不夠的

比如：讀寫鎖更靈活

3、無法預判是否成功獲取到鎖
七、常見問題
1、synchronized關鍵字注意點：

鎖對象不能爲空
作用域不宜過大
避免死鎖
2、如何選擇Lock和synchronized關鍵字？

總結建議（優先避免出錯的原則）：

如果可以的話，儘量優先使用java.util.concurrent各種類（不需要考慮同步工作，不容易出錯）
優先使用synchronized，這樣可以減少編寫代碼的量，從而可以減少出錯率
若用到Lock或Condition獨有的特性，才使用Lock或Condition
八、總結
一句話總結synchronized：

JVM會自動通過使用monitor來加鎖和解鎖，保證了同一時刻只有一個線程可以執行指定的代碼，從而保證線程安全，同時具有可重入和不可中斷的特性。
原文地址https://www.cnblogs.com/JsonShare/p/11433302.html

Java之戳中痛點 - （8）synchronized深度解析

電子科技大學計算機科學與技術就讀體驗

Golang爬蟲代理接入的技術與實踐

JAVA concurrency -- CyclicBarrier 與 CountDownLatch 源碼詳解

JAVA concurrency -- 阻塞隊列ArrayBlockingQueue源碼詳解

mycat自動重啓解決辦法

搭建websocket消息推送服務，必須要考慮的幾個問題

Nacos作爲微服務註冊中心，愛不釋手的感覺

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結