Synchronized關鍵字

hqman 發布于2019-08-19 11:37 / 2101人閱讀

摘要：我叫運行結束三線程不安全導致請求丟失問題解決場景前面一的作用中的計數場景。我叫運行結束方法拋異常后，是否會釋放鎖拋出異常之后會釋放鎖，后面的線程會進入同步方法。當一個線程獲得了對應的鎖的時候，其他線程只能等待我釋放之后才能獲取該鎖。

一、Synchronized的作用

作用：能夠保證在同一時刻最多只有一個線程執行該代碼，以達到保證并發安全的效果

public class DisappearRequest implements Runnable{
    
    static DisappearRequest dr = new DisappearRequest();
    
    static int count = 0;
    
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(dr);
        Thread t2 = new Thread(dr);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("count="+count);
    }

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

}
// 結果count小于20000（線程不安全）

二、Synchronized的兩個用法

1. 對象鎖：包括同步代碼塊鎖（自己指定鎖對象）和方法鎖（默認鎖對象為this當前實例對象）

1.1 代碼塊形式：手動指定鎖對象

public class SynchronizedObjectCodeBlock implements Runnable {
    
    static SynchronizedObjectCodeBlock instance = 
            new SynchronizedObjectCodeBlock();
    
    
    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        
        t1.start();
        t2.start();
        
        while(t1.isAlive() || t2.isAlive()){
            
        }
        System.out.println("finished");
    }

    @Override
    public void run() {
        // 兩個線程串行操作
        synchronized(this){
            System.out.println("我是對象鎖的代碼塊形式。我叫:" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "運行結束");
        }
    }

}

public class SynchronizedObjectCodeBlock implements Runnable {
    
    static SynchronizedObjectCodeBlock instance = 
            new SynchronizedObjectCodeBlock();
    
    Object lock1 = new Object();
    Object lock2 = new Object();
    
    
    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        
        t1.start();
        t2.start();
        
        while(t1.isAlive() || t2.isAlive()){
            
        }
        System.out.println("finished");
    }

    @Override
    public void run() {
        synchronized(lock1){
            System.out.println("我是對象鎖的代碼塊形式。我叫:" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "運行結束");
        }
        
        synchronized(lock2){
            System.out.println("我是對象鎖的代碼塊形式。我叫:" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "運行結束");
        }
    }

}
// CountDownLatch、信號量解決線程同步問題。

1.2 方法鎖形式：synchronized修飾普通方法，鎖對象默認為this
普通方法鎖

public class SynchronizedMethodLock implements Runnable{

    static SynchronizedMethodLock instance = 
            new SynchronizedMethodLock();
    
    @Override
    public void run() {
        sync();
    }
    
    // 普通方法鎖（不能是靜態方法。鎖對象默認是this）
    public synchronized void sync(){
        System.out.println("我是普通方法鎖形式。我叫:" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "運行結束");
    }
    
    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        
        t1.start();
        t2.start();
        
        while(t1.isAlive() || t2.isAlive()){
            
        }
        System.out.println("finished");
    }
    
    

}

2. 類鎖：指synchronized修飾靜態方法或指定鎖為Class對象。Java類可能有很多個對象，但只有一個Class對象。
所謂的類鎖，不過是Class對象的鎖而已。
用法和效果：類鎖只能在同一時刻被一個對象擁有，其他對象會被阻塞
對象鎖如果不同的實例創建出來的，互相鎖是不受影響的，你可以運行我也可以運行，并行運行，但是類鎖只有一個可以運行。

2.1. synchronized加在static方法上。場景：如果需要在全局情況下同步該方法，而不是一個小范圍層面，則應該用這種形式去做同步保護。

public class SynchronizedMethodLock implements Runnable{

    // 創建兩個實例對象
    static SynchronizedMethodLock instance1 = 
            new SynchronizedMethodLock();
    static SynchronizedMethodLock instance2 = 
            new SynchronizedMethodLock();
    
    @Override
    public void run() {
        sync();
    }
    
    // 創建兩個實例對象，如果不是static方法的話，則并行操作，否則串行執行。
    public static synchronized void sync(){
        System.out.println("我是類鎖的第一種形式：static形式。我叫:" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "運行結束");
    }
    
    public static void main(String[] args) {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        
        t1.start();
        t2.start();
        
        while(t1.isAlive() || t2.isAlive()){
            
        }
        System.out.println("finished");
    }
    
    

}

2.2. synchronized（*.class）代碼塊

public class SynchronizedMethodLock implements Runnable{

    // 創建兩個實例對象
    static SynchronizedMethodLock instance1 = 
            new SynchronizedMethodLock();
    static SynchronizedMethodLock instance2 = 
            new SynchronizedMethodLock();
    
    @Override
    public void run() {
        sync();
    }
    
    // 創建兩個實例對象，如果不是static方法的話，則并行操作，否則串行執行。
    public void sync(){
        // 如果是this的話則并行執行，Class對象則串行執行
        synchronized(SynchronizedMethodLock.class){
            System.out.println("我是類鎖的第二種形式：synchronized(*.class)形式。我叫:" + Thread.currentThread().getName());
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "運行結束");
            }
    }
    
    public static void main(String[] args) {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        
        t1.start();
        t2.start();
        
        while(t1.isAlive() || t2.isAlive()){
            
        }
        System.out.println("finished");
    }
    
    

}

三、線程不安全導致請求丟失問題解決

場景：前面【一、Synchronized的作用 】中的demo計數場景。
如下四種方式解決(結果均為20000)：

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

3.2
@Override
    public void run() {
        synchronized (this){
            for (int i = 0; i < 10000; i++) {
                count++;
            }
        }
    }

3.3
@Override
    public void run() {
        synchronized(DisappearRequest.class){
            for (int i = 0; i < 10000; i++) {
                count++;
            }
        }
    }

3.4
@Override
    public void run() {
        add();
    }
    
    public static synchronized void add(){
        for (int i = 0; i < 10000; i++) {
            count++;
        }
    }

四、多線程訪問同步方法的7中情況

4.1、兩個線程同時訪問一個對象的同步方法

兩個線程爭搶的是同一把鎖，線程間相互等待，只能有一個線程持有該鎖

public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        while(t1.isAlive() || t2.isAlive()){
        }
        System.out.println("finished");
    }

4.2、兩個線程訪問的是兩個對象的同步方法

創建兩個實例對象，如果不是static方法的話，則并行操作，否則串行執行，這兩個實例真正采用的鎖對象不是同一個，所以不會被干擾。

// 創建兩個實例對象，如果不是static方法的話，則并行操作，否則串行執行。
    public void sync(){
        // 如果是this的話則并行執行,指向的是不同的實例對象，若為Class對象則串行執行
        synchronized(this){
        // TO DO...
        }
    }
public static void main(String[] args) {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
        while(t1.isAlive() || t2.isAlive()){    
        }
        System.out.println("finished");
    }

4.3、兩個線程訪問的synchronized的靜態方法

如果兩個線程訪問的是同一個對象的同步方法則串行執行，如果訪問的是不同對象的同步方法，若該方法是非靜態static方法則并行執行，否則兩個線程訪問的鎖對象為同一把鎖，串行執行。

    public static synchronized void sync(){
    // TO DO...
    }
    
    public static void main(String[] args) {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        
        t1.start();
        t2.start();
        
        while(t1.isAlive() || t2.isAlive()){
            
        }
        System.out.println("finished");
    }

4.4 同時訪問同步方法合肥同步方法

非同步方法不受到影響

4.5 訪問同一個對象的不同的普通同步方法

同一個對象，兩個同步方法拿到的this是一樣的，同一把鎖，所以串行執行

4.6 同時訪問靜態synchronized和非靜態synchronized方法

兩個線程指定的鎖對象不是同一把鎖，所以鎖之間不沖突，并行執行

// 創建兩個實例對象，如果不是static方法的話，則并行操作，否則串行執行。
    public static synchronized void sync(){
        // 如果是this的話則并行執行，Class對象則串行執行
        System.out.println("我是靜態方法：synchronized(*.class)形式。我叫:" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "運行結束");
    }
    
    // 創建兩個實例對象，如果不是static方法的話，則并行操作，否則串行執行。
    public synchronized void sync1(){
        // 如果是this的話則并行執行，Class對象則串行執行
        System.out.println("我是非靜態方法：synchronized(*.class)形式。我叫:" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "運行結束");
    }
    
    public static void main(String[] args) {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance1);
        
        t1.start();
        t2.start();
        
        while(t1.isAlive() || t2.isAlive()){
            
        }
        System.out.println("finished");
    }

4.7 方法拋異常后，是否會釋放鎖

拋出異常之后jvm會釋放鎖，后面的線程會進入同步方法。

// 創建兩個實例對象
    static SynchronizedMethodLock instance1 = 
            new SynchronizedMethodLock();
    static SynchronizedMethodLock instance2 = 
            new SynchronizedMethodLock();
    
    @Override
    public void run() {
        if(Thread.currentThread().getName().equals("Thread-0")){
            sync();
        }else{
            sync1();
        }
    }
    
    // 創建兩個實例對象，如果不是static方法的話，則并行操作，否則串行執行。
    public synchronized void sync(){
        // 如果是this的話則并行執行，Class對象則串行執行
        System.out.println("我是方法1：我叫:" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        throw new RuntimeException();
//        System.out.println(Thread.currentThread().getName() + "運行結束");
    }
    
    // 創建兩個實例對象，如果不是static方法的話，則并行操作，否則串行執行。
    public synchronized void sync1(){
        // 如果是this的話則并行執行，Class對象則串行執行
        System.out.println("我是方法2：我叫:" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "運行結束");
    }
    
    public static void main(String[] args) {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance1);
        
        t1.start();
        t2.start();
        
        while(t1.isAlive() || t2.isAlive()){
            
        }
        System.out.println("finished");
    }

五、synchronized的性質

【5.1 可重入】：指的是同一線程的外層函數獲得鎖之后，內層函數可以直接再次獲取該鎖
好處：避免死鎖，提升封裝性
比如：現在有兩個均被synchronized修飾的方法f1和f2，此時線程A執行到了f1，并且獲得了這把鎖，由于方法二f2也是synchronized修飾（也就是說要執行f2必須拿到f2的鎖），如果synchronized不具備可重入性，此時線程A只是拿到了f1的鎖，沒有拿到f2的鎖，所以線程A即想拿到f2的鎖又不釋放f1鎖，那么就會造成永遠等待，即死鎖，所以synchronized是具有可重入性。

【可重入粒度如下】

5.1.1 證明同一個方法是可重入的（遞歸）

5.1.2 證明可重入不要求是同一個方法

public synchronized void method1(){
        System.out.println("我是method1");
        method2();
    }
    public synchronized void method2(){
        System.out.println("我是method2");
    }

5.1.3 證明同可重入不要求是同一個類中的

public class SyncSuperClass{
        public synchronized void doSomething(){
            System.out.println("我是父類方法");
        }
    }
    
    class TestClass extends SyncSuperClass{
        public synchronized void doSomething(){
            System.out.println("我是子類方法");
            super.doSomething();
        }
    }

【5.2 不可中斷性】

一旦這個鎖已經被別人獲得了，如果我還想獲得，我只能選擇等待或者阻塞，直到別的線程釋放這個鎖。如果別人永遠不釋放鎖，那么我只能永遠等下去。
Lock類：相比之下，Lock類，可以擁有中斷的能力，第一點，如果我覺得我等的時間太長了，有權中斷現在已經獲取到鎖的線程的執行；第二點，如果我覺得等待時間太長了不想等了，可以退出。

Lock lock = new ReentrantLock(); 
    // 下面這兩種形式的鎖是等價的
    public synchronized void method1(){
        System.out.println("我是Synchronized形式的鎖");
    }
    
    public void method2(){
        lock.lock();
        try{
            System.out.println("我是Lock形式的鎖");
        }finally{
            lock.unlock();
        }
    }

六、synchronized的缺陷

【6.1 效率低】

鎖的釋放情況少，試圖獲得鎖時不能設定超時、不能中斷一個正在試圖獲得鎖的線程。
6.1.1、 當一個線程獲得了對應的sync鎖的時候，其他線程只能等待我釋放之后才能獲取該鎖。
6.1.2、 只有兩種情況才釋放鎖：1.執行完了這段代碼，2.發生異常自動釋放鎖
6.1.3、 不能中斷，但是Lock是有中斷能力的

【6.2 不夠靈活（如：讀寫鎖比較靈活：讀的時候不加鎖，寫才加鎖）】

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

【6.3 無法知道是否成功獲取到鎖】

七、Lock鎖常用方法

    Lock lock = new ReentrantLock(); // 非公平鎖
    // Lock lock = new ReentrantLock(true); // 公平鎖
    // Lock lock = new ReentrantReadWriteLock();
        
        lock.lock();
        lock.unlock();
        lock.tryLock(); // 獲取鎖
        lock.tryLock(10, TimeUnit.SECONDS);

八、常見面試題

8.1 使用synchroinzed注意點：鎖對象不能為空、作用域不宜過大、避免死鎖
注：一個對象作為鎖對象，這個對象必須是被new過的，或者是被其他方法創建好的，而不是一個空對象，因為鎖的信息保存在對象頭中的。

8.2 如何選擇Lock和synchronized關鍵字
盡量使用concurrent包下的CountDownLatch或者atomic包，或者信號量

九、思考

9.1 多個線程等待同一個synchronized鎖的時候，JVM如何選擇下一個獲取鎖的是哪個縣城？
9.2 synchronized使得同時只能有一個線程可以執行，性能較差，有什么辦法可以提升性能？
9.3 我想更靈活的控制鎖的獲取和釋放（現在釋放鎖的時機都被規定死了），怎么辦？
9.4 什么是鎖的升級、降級？什么事JVM里的偏斜所、輕量級鎖。重量級鎖？

GPU云服務器云服務器 synchronized關鍵字 synchronized java synchronized synchronized java鎖

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/77565.html

synchronized關鍵字使用詳解

摘要：基本使用同步代碼塊同步代碼塊延時秒，方便后面測試作用代碼塊時，方法中的，是指調用該方法的對象。那么這個時候使用關鍵字就需要注意了推薦使用同步代碼塊，同步的代碼塊中傳入外部定義的一個變量。簡述計算機單線程在執行任務時，是嚴格按照程序的代碼邏輯，按照順序執行的。因此單位時間內能執行的任務數量有限。為了能在相同的時間內能執行更多的任務，就必須采用多線程的方式來執行（注意：多線程模式無法減...

Jeffrrey 2019-08-16 17:09 評論0 收藏0
Java中的synchronized關鍵字

摘要：的關鍵字中的塊使用關鍵字進行標記。由于每個類只有一個類對象存在于中，因此全局同時只有一個線程能夠進入到同一個類的靜態同步方法中。同步代碼塊使這種期望成為可能。注意同步代碼塊如何在括號中接受一個對象。相同的實例被傳入兩個不同的線程實例中。 Java的synchronized塊標記一個方法或一個代碼塊為同步的。synchronized塊能用于防止出現競態條件。 Java的synchroni...

lylwyy2016 2019-08-19 10:24 評論0 收藏0
值得保存的 synchronized 關鍵字總結

摘要：無論是互斥鎖，還是自旋鎖，在任何時刻，最多只能有一個保持者，也就說，在任何時刻最多只能有一個執行單元獲得鎖。另外在中引入了自適應的自旋鎖。和關鍵字的總結推薦一該文已加入開源文檔：JavaGuide（一份涵蓋大部分Java程序員所需要掌握的核心知識）。地址:https://github.com/Snailclimb... 本文是對 synchronized 關鍵字使用、底層原理、JD...

miguel.jiang 2019-08-19 11:06 評論0 收藏0
Java多線程學習（二）synchronized關鍵字（2）

摘要：關鍵字加到非靜態方法上持有的是對象鎖。線程和線程持有的鎖不一樣，所以和運行同步，但是和運行不同步。所以盡量不要使用而使用參考多線程編程核心技術并發編程的藝術如果你覺得博主的文章不錯，歡迎轉發點贊。系列文章傳送門: Java多線程學習（一）Java多線程入門 Java多線程學習（二）synchronized關鍵字（1） java多線程學習（二）synchronized關鍵字（2） J...

Batkid 2019-08-15 15:30 評論0 收藏0
Java多線程學習（二）synchronized關鍵字（1）

摘要：轉載請備注地址多線程學習二將分為兩篇文章介紹同步方法另一篇介紹同步語句塊。如果兩個線程同時操作對象中的實例變量，則會出現非線程安全，解決辦法就是在方法前加上關鍵字即可。轉載請備注地址： https://blog.csdn.net/qq_3433... Java多線程學習（二）將分為兩篇文章介紹synchronized同步方法另一篇介紹synchronized同步語句塊。系列文章傳送門...

xuxueli 2019-08-15 15:30 評論0 收藏0
Synchronized 關鍵字使用、底層原理、JDK1.6 之后的底層優化以及和ReenTran

摘要：使用可以禁止的指令重排，保證在多線程環境下也能正常運行。關鍵字底層原理總結關鍵字底層原理屬于層面。另外在中引入了自適應的自旋鎖。自適應的自旋鎖帶來的改進就是自旋的時間不在固定了，而是和前一次同一個鎖上的自旋時間以及鎖的擁有者【強烈推薦！非廣告！】阿里云雙11褥羊毛活動：https://m.aliyun.com/act/team1111/#/share?params=N.FF7yxCc...

Vixb 2019-08-16 13:31 評論0 收藏0