2. 程式人生 > >【從入門到放棄-Java】併發程式設計-鎖-synchronized

【從入門到放棄-Java】併發程式設計-鎖-synchronized

阿新 • • 發佈：2019-08-17

簡介

上篇【從入門到放棄-Java】併發程式設計-執行緒安全中，我們瞭解到，可以通過加鎖機制來保護共享物件，來實現執行緒安全。

synchronized是java提供的一種內建的鎖機制。通過synchronized關鍵字同步程式碼塊。執行緒在進入同步程式碼塊之前會自動獲得鎖，並在退出同步程式碼塊時自動釋放鎖。內建鎖是一種互斥鎖。

本文來深入學習下synchronized。

使用

同步方法

同步非靜態方法

public class Synchronized {
    private static int count;

    private synchronized void add1() {
        count++;
        System.out.println(count);
    }

    public static void main(String[] args) throws InterruptedException {
        Synchronized sync = new Synchronized();
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i< 10000; i++) {
                sync.add1();
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i< 10000; i++) {
                sync.add1();

            }
        });

        thread1.start();
        thread2.start();
        Thread.sleep(1000);
        System.out.println(count);
    }
}

結果符合預期：synchronized作用於非靜態方法，鎖定的是例項物件，如上所示鎖的是sync物件，因此執行緒能夠正確的執行，count的結果總會是20000。

public class Synchronized {
    private static int count;

    private synchronized void add1() {
        count++;
        System.out.println(count);
    }

    public static void main(String[] args) throws InterruptedException {
        Synchronized sync = new Synchronized();
        Synchronized sync1 = new Synchronized();
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i< 10000; i++) {
                sync.add1();
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i< 10000; i++) {
                sync1.add1();
            }
        });

        thread1.start();
        thread2.start();
        Thread.sleep(1000);
        System.out.println(count);
    }
}

結果不符合預期：如上所示，作用於非靜態方法，鎖的是例項化物件，因此當sync和sync1同時執行時，還是會出現執行緒安全問題，因為鎖的是兩個不同的例項化物件。

同步靜態方法

public class Synchronized {
    private static int count;

    private static synchronized void add1() {
        count++;
        System.out.println(count);
    }

    private static synchronized void add11() {
        count++;
        System.out.println(count);
    }

    public static void main(String[] args) throws InterruptedException {
        Synchronized sync = new Synchronized();
        Synchronized sync1 = new Synchronized();
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i< 10000; i++) {
                Synchronized.add1();
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i< 10000; i++) {
                Synchronized.add11();

            }
        });

        thread1.start();
        thread2.start();
        Thread.sleep(1000);
        System.out.println(count);
    }
}

結果符合預期：鎖靜態方法時，鎖的是類物件。因此在不同的執行緒中呼叫add1和add11依然會得到正確的結果。

同步程式碼塊

鎖當前例項物件

public class Synchronized {
    private static int count;

    private void add1() {
        synchronized (this) {
            count++;
            System.out.println(count);
        }
    }

    private static synchronized void add11() {
        count++;
        System.out.println(count);
    }

    public static void main(String[] args) throws InterruptedException {
        Synchronized sync = new Synchronized();
        Synchronized sync1 = new Synchronized();
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i< 10000; i++) {
                sync.add1();
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i< 10000; i++) {
                sync1.add1();
            }
        });

        thread1.start();
        thread2.start();
        Thread.sleep(1000);
        System.out.println(count);
    }
}

結果不符合預期：當synchronized同步方法塊時，鎖的是例項物件時，如上示例在不同的例項中呼叫此方法還是會出現執行緒安全問題。

鎖其它例項物件

public class Synchronized {
    private static int count;
    public String lock = new String();

    private void add1() {
        synchronized (lock) {
            count++;
            System.out.println(count);
        }
    }

    private static synchronized void add11() {
        count++;
        System.out.println(count);
    }

    public static void main(String[] args) throws InterruptedException {
        Synchronized sync = new Synchronized();
        Synchronized sync1 = new Synchronized();
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i< 10000; i++) {
                sync.add1();
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i< 10000; i++) {
                sync1.add1();
            }
        });

        thread1.start();
        thread2.start();
        Thread.sleep(1000);
        System.out.println(count);

        System.out.println(sync.lock == sync1.lock);
    }
}

結果不符合預期：當synchronized同步方法塊時，鎖的是其它例項物件時，如上示例在不同的例項中呼叫此方法還是會出現執行緒安全問題。

public class Synchronized {
    private static int count;
    public String lock = "";

    private void add1() {
        synchronized (lock) {
            count++;
            System.out.println(count);
        }
    }

    private static synchronized void add11() {
        count++;
        System.out.println(count);
    }

    public static void main(String[] args) throws InterruptedException {
        Synchronized sync = new Synchronized();
        Synchronized sync1 = new Synchronized();
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i< 10000; i++) {
                sync.add1();
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i< 10000; i++) {
                sync1.add1();
            }
        });

        thread1.start();
        thread2.start();
        Thread.sleep(1000);
        System.out.println(count);

        System.out.println(sync.lock == sync1.lock);
    }
}

結果符合預期：當synchronized同步方法塊時，鎖的雖然是其它例項物件時，但已上例項中，因為String = "" 是存放在常量池中的，實際上鎖的還是相同的物件，因此是執行緒安全的

鎖類物件

public class Synchronized {
    private static int count;

    private void add1() {
        synchronized (Synchronized.class) {
            count++;
            System.out.println(count);
        }
    }

    private static synchronized void add11() {
        count++;
        System.out.println(count);
    }

    public static void main(String[] args) throws InterruptedException {
        Synchronized sync = new Synchronized();
        Synchronized sync1 = new Synchronized();
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i< 10000; i++) {
                sync.add1();
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i< 10000; i++) {
                sync1.add1();
            }
        });

        thread1.start();
        thread2.start();
        Thread.sleep(1000);
        System.out.println(count);
    }
}

結果符合預期：當synchronized同步方法塊時，鎖的是類物件時，如上示例在不同的例項中呼叫此方法是執行緒安全的。

鎖機制

public class Synchronized {
    private static int count;

    public static void main(String[] args) throws InterruptedException {
        synchronized (Synchronized.class) {
            count++;
        }
    }
}

使用javap -v Synchronized.class反編譯class檔案。

可以看到synchronized實際上是通過monitorenter和monitorexit來實現鎖機制的。同一時刻，只能有一個執行緒進入監視區。從而保證執行緒的同步。

正常情況下在指令4進入監視區，指令14退出監視區然後指令15直接跳到指令23 return

但是在異常情況下異常都會跳轉到指令18，依次執行到指令20monitorexit釋放鎖，防止出現異常時未釋放的情況。
這其實也是synchronized的優點：無論程式碼執行情況如何，都不會忘記主動釋放鎖。

想了解Monitors更多的原理可以點選檢視

鎖升級

因為monitor依賴作業系統的Mutex lock實現，是一個比較重的操作，需要切換系統至核心態，開銷非常大。因此在jdk1.6引入了偏向鎖和輕量級鎖。
synchronized有四種狀態：無鎖 -> 偏向鎖 -> 輕量級鎖 -> 重量級鎖。

無鎖

沒有對資源進行鎖定，所有執行緒都能訪問和修改。但同時只有一個執行緒能修改成功

偏向鎖

在鎖競爭不強烈的情況下，通常一個執行緒會多次獲取同一個鎖，為了減少獲取鎖的代價 引入了偏向鎖，會在java物件頭中記錄獲取鎖的執行緒的threadID。

  • 當執行緒發現物件頭的threadID存在時。判斷與當前執行緒是否是同一執行緒。
  • 如果是則不需要再次加、解鎖。
  • 如果不是，則判斷threadID是否存活。不存活：設定為無鎖狀態，其他執行緒競爭設定偏向鎖。存活：查詢threadID堆疊資訊判斷是否需要繼續持有鎖。需要持有則升級threadID執行緒的鎖為輕量級鎖。不需要持有則撤銷鎖，設定為無鎖狀態等待其它執行緒競爭。

因為偏向鎖的撤銷操作還是比較重的，導致進入安全點，因此在競爭比較激烈時，會影響效能，可以使用-XX:-UseBiasedLocking=false禁用偏向鎖。

輕量級鎖

當偏向鎖升級為輕量級鎖時，其它執行緒嘗試通過CAS方式設定物件頭來獲取鎖。

  • 會先在當前執行緒的棧幀中設定Lock Record，用於儲存當前物件頭中的mark word的拷貝。
  • 複製mark word的內容到lock record，並嘗試使用cas將mark word的指標指向lock record
  • 如果替換成功，則獲取偏向鎖
  • 替換不成功，則會自旋重試一定次數。
  • 自旋一定次數或有新的執行緒來競爭鎖時，輕量級鎖膨脹為重量級鎖。

CAS

CAS即compare and swap（比較並替換）。是一種樂觀鎖機制。通常有三個值

  • V：記憶體中的實際值
  • A：舊的預期值
  • B：要修改的新值
    即V與A相等時，則替換V為B。即記憶體中的實際值與我們的預期值相等時，則替換為新值。

CAS可能遇到ABA問題，即記憶體中的值為A，變為B後，又變為了A，此時A為新值，不應該替換。
可以採取：A-1，B-2，A-3的方式來避免這個問題

重量級鎖

自旋是消耗CPU的，因此在自旋一段時間，或者一個執行緒在自旋時，又有新的執行緒來競爭鎖，則輕量級鎖會膨脹為重量級鎖。
重量級鎖，通過monitor實現，monitor底層實際是依賴作業系統的mutex lock（互斥鎖）實現。
需要從使用者態，切換為核心態，成本比較高

總結

本文我們一起學習了

  • synchronized的幾種用法：同步方法、同步程式碼塊。實際上是同步類或同步例項物件。
  • 鎖升級：無鎖、偏向鎖、輕量級鎖、重量級鎖以及其膨脹過程。

synchronized作為內建鎖，雖然幫我們解決了執行緒安全問題，但是帶來了效能的損失，因此一定不能濫用。使用時請注意同步塊的作用範圍。通常，作用範圍越小，對效能的影響也就越小（注意權衡獲取、釋放鎖的成本，不能為了縮小作用範圍，而頻繁的獲取、釋放）。


本文作者：aloof_

原文連結

本文為雲棲社群原創內容，未經

相關推薦

【從入門到放棄-Java】併發程式設計-鎖-synchronized

簡介 上篇【從入門到放棄-Java】併發程式設計-執行緒安全中，我們瞭解到，可以通過加鎖機制來保護共享物件，來實現執行緒安全。

【從入門到放棄-Java】併發程式設計-NIO-Channel

簡介 channel即通道，可以用來讀、寫資料，它是全雙工的可以同時用來讀寫操作。這也是它與stream流的最大區別。 channel需要與buffer配合使用，channel通道的一端是buffer，一端是資料來源實體，如檔案、socket等。在nio中，通過channel的不同實現來處理 不同實

【從入門到放棄-Java】併發程式設計-執行緒安全

概述 併發程式設計，即多條執行緒在同一時間段內“同時”執行。 在多處理器系統已經普及的今天，多執行緒能發揮出其優勢，如：一個

【從入門到放棄-Java】併發程式設計-NIO使用

前言 上文【從入門到放棄-SpringBoot】SpringBoot原始碼分析-請求過程中我們瞭解到，tomcat接收、返回請

Java程式設計師必備後臺前端框架--Layui【從入門到實戰】（一）

layui入門使用及圖示、按鈕的使用 作者 ： Stanley 羅昊 【轉載請註明出處和署名，謝謝！】 【程式設計工具：IDEA】 下載Layui與檔案分析 下載直接去官網下載即可 檔案分析 下載完成後，解壓會得到一個資料夾，內部有一些檔案是可以直接刪除的，比如文件與示例，更新日誌之類的，我們僅僅只要上面那

Java程式設計師必備後臺前端框架--Layui【從入門到實戰】（二）

layui使用 導航選單、選項卡 作者 ： Stanley 羅昊 【轉載請註明出處和署名，謝謝！】 【程式設計工具：IDEA】 導航選單 在layui官網中示例中，我們可以找到關於導航的例子：  我們點選檢視程式碼，將其程式碼複製到自己的編輯器上； 1 <fieldset class="

kuangbin專題四 最短路練習【從入門到熟練】

clu struct sin img urn star 通路 gif col 【POJ 2253 Frogger】 這道題求從u到v中所有通路的最大邊最小 我直接二分做了，但實際上這種題是最短路算法的變種，意義在於告訴我們spfa這些算法不僅能維護出最短路，稍加修改後可以維

kuangbin專題十二 基礎DP1【從入門到熟練】【9+1題】

HDU1024 Max Sum Plus Plus 感覺這題是整個系列裡難度最高的題之一？ #include<bits/stdc++.h> #include<stdio.h> #include<iostream> #include<algor

【從零學java】猜數字遊戲——了解類與對象

ring == src layer stat 猜數字 false mat think 通過猜數字遊戲，開始了解類和對象。 遊戲概要：產生一個0-9間的隨機數，3個player猜，若有猜中者則遊戲結束，猜不中下一輪繼續猜。 類：GuessGame.class、Player.c

【進階之路】併發程式設計（三）-非阻塞同步機制

## 導言 >這一篇的內容主要來自於《java併發程式設計實戰》，有一說一，看這種寫的很專業的書不是很輕鬆，也沒辦法直接提高多少開發的能力，但是卻能更加夯實基礎，就像玩war3，熟練的基本功並不能讓你快速地與對方拉開差距，但是卻能再每一次團戰中積累優勢。 近年來，併發程式設計的領域更多的偏向於使用非阻

Java高併發程式設計之synchronized關鍵字（二）

上一篇文章講了synchronized的部分關鍵要點，詳見：Java高併發程式設計之synchronized關鍵字（一） 本篇文章接著講synchronized的其他關鍵點。 在使用synchronized關鍵字的時候，不要以字串常量作為鎖定物件。看下面的例子： public class

Java高併發程式設計之synchronized關鍵字（一）

首先看一段簡單的程式碼： public class T001 { private int count = 0; private Object o = new Object(); public void m() { //任何執行緒要執行下面這段程式碼

【JAVA筆記——道】併發程式設計CAS演算法

併發程式設計中，一個很重要的包時concurrent包，concurrent包實現併發控制核心原理之一是CAS演算法，相比起鎖/volatile/synchronized/遮蔽/柵欄這些方式，CAS的實現機制到底有什麼優勢。 CAS (Compare And

【Python程式設計：從入門到實踐】第九章：類

9-1 餐館 ：建立一個名為Restaurant 的類，其方法__init__() 設定兩個屬性：restaurant_name 和cuisine_type 。建立一個名 為describe_restaurant() 的方法和一個名為open_restaurant() 的方

【備忘】Java高併發程式設計實戰視訊教程

課程簡介：隨著多核時代的興起，現在的伺服器CPU可能多達10個以上的核心。對於併發程式設計的市場需求量激增，那麼如何才能將多核CPU的效能發揮到極致呢？而Java作為服務端程式設計使用最廣泛的語言，必然需要和多核CPU打交道。那Java為我們提供了哪些併發程式設計的工具呢？

【Python程式設計：從入門到實踐】第十五章：生成資料

15-1 立方：數字的三次方被稱為其立方。請繪製一個圖形，顯示前5個整數的立方值，在繪製一個圖形，顯示前面5000個整數的立方值。 前5個整數的立方值：import matplotlib.pyplot as plt x_values = [1,2,3,4,5] y_val

【Python程式設計：從入門到實踐】第十二章：武裝飛船

12-1 藍色天空 ：建立一個背景為藍色的Pygame視窗。 import sys import pygame def run(): pygame.init() screen = pygame.display.set_mode((1200,600)) pygame.d

【Java併發基礎】併發程式設計領域的三個問題：分工、同步和互斥

前言 可以將Java併發程式設計抽象為三個核心問題：分工、同步和互斥。 這三個問題的產生源自對效能的需求。最初時，為提高計算機的效率，當IO在等待時不讓CPU空閒，於是就出現了分時作業系統也就出現了併發。後來，多核CPU出現，不同的任務可以同時獨立執行，於是就出現了並行【分工】。有了分工後，效率得到了很大的提

【Java併發基礎】併發程式設計bug源頭：可見性、原子性和有序性

前言 CPU 、記憶體、I/O裝置之間的速度差距十分大，為了提高CPU的利用率並且平衡它們的速度差異。計算機體系結構、作業系統和編譯程式都做出了改進： CPU增加了快取，用於平衡和記憶體之間的速度差異。 作業系統增加了程序、執行緒，以時分複用CPU，進而均衡CPU與I/O裝置之間的速度差異。 編譯程式優化指

【Python編程-從入門到實踐】定義大範圍的整數數組range ( 從哪個整數開始，到哪個整數前結束 ，[從開始到結束的整數的每次步長] )

文檔 list 步長 字符串 range 不能 結果 字符 for range(1,5)　　定義了從1開始到4的整數　　[1,2,3,4] 場景1： numbers = range(1,5) for num in numbers: 　　print(num) 【結果】 1 2