原創宣告：本文轉載自公眾號【胖滾豬學編程】，轉載務必注明出處！

在并發編程BUG源頭文章中，我們初識了并發編程的三個bug源頭：可見性、原子性、有序性，在如何解決可見性和原子性文章中我們大致了解了可見性和有序性的解決思路，今天輪到最后一個大bug，那就是原子性，

知識回顧

鎖模型

JAVA中的鎖模型

鎖是一種通用的技術方案，Java 語言提供的 synchronized 關鍵字，就是鎖的一種實作，

• synchronized 是獨占鎖/排他鎖（就是有你沒我的意思），但是注意！synchronized并不能改變CPU時間片切換的特點，只是當其他執行緒要訪問這個資源時，發現鎖還未釋放，所以只能在外面等待，
• synchronized一定能保證原子性，因為被 synchronized 修飾某段代碼后，無論是單核 CPU 還是多核 CPU，只有一個執行緒能夠執行該代碼，所以一定能保證原子操作
• synchronized也能夠保證可見性和有序性，根據前第二篇文章：Happens-Before 規則之管程中鎖的規則：對一個鎖的解鎖 Happens-Before 于后續對這個鎖的加鎖，即前一個執行緒的解鎖操作對后一個執行緒的加鎖操作可見，綜合 Happens-Before 的傳遞性原則，我們就能得出前一個執行緒在臨界區修改的共享變數（該操作在解鎖之前），對后續進入臨界區（該操作在加鎖之后）的執行緒是可見的，- synchronized 關鍵字可以用來修飾靜態方法，非靜態方法，也可以用來修飾代碼塊

理論說完了，來點實際的吧！首先我們用synchronized 修飾非靜態方法來改寫第一章中原子性問題的那段代碼：

    private long count = 0;
    
    // 修飾非靜態方法 當修飾非靜態方法的時候，鎖定的是當前實體物件 this，
    // 當該類中有多個普通方法被Synchronized修飾（同步），那么這些方法的鎖都是這個類的一個物件this，多個執行緒訪問這些方法時，如果這些執行緒呼叫方法時使用的是同一個該類的物件，雖然他們訪問不同方法，但是他們使用同一個物件來呼叫，那么這些方法的鎖就是一樣的，就是這個物件，那么會造成阻塞，如果多個執行緒通過不同的物件來呼叫方法，那么他們的鎖就是不一樣的，不會造成阻塞，
    private synchronized void add10K(){
        int start = 0;
        while (start ++ < 10000){
            this.count ++;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TestSynchronized2 test = new TestSynchronized2();
        // 創建兩個執行緒，執行 add() 操作
        Thread th1 = new Thread(()->{
            test.add10K();
        });
        Thread th2 = new Thread(()->{
            test.add10K();
        });
        // 啟動兩個執行緒
        th1.start();th2.start();
        // 等待兩個執行緒執行結束
        th1.join();th2.join();
        System.out.println(test.count);
    }

運行一下吧！你會發現永遠都可以達到我們想要的效果了~
除了上面代碼中修飾非靜態方法，還可以修飾靜態方法和代碼塊

    // 修飾靜態方法 當修飾靜態方法的時候，鎖定的是當前類的 Class 物件，即TestSynchronized2.class ，這個范圍就比物件鎖大，這里就算是不同物件，但是只要是該類的物件，就使用的是同一把鎖，
    synchronized static void bar() {
        // 臨界區
    }
    // 修飾代碼塊 java中經典的雙重鎖檢查機制
    private volatile static TestSynchronized2 instance;
    public static TestSynchronized2 getInstance() {
        if (instance == null) {
            synchronized (TestSynchronized2.class) {
                if (instance == null) {
                    instance = new TestSynchronized2();
                }
            }
        }
        return instance;
    }

明確鎖和資源的關系

深入分析鎖定的物件和受保護資源的關系，綜合考慮受保護資源的訪問路徑，多方面考量才能用好互斥鎖，受保護資源和鎖之間的關聯關系是 N:1 的關系，如果一個資源用N個鎖，那肯定出問題的，就好像一個廁所坑位，你有10把鑰匙，那不是可以10個人同時進了？

現在給出兩段錯誤代碼，想一想到底為啥錯了吧？

    static long value1 = 0L;

    synchronized long get1() {
        return value1;
    }

    synchronized static void addOne1() {
        value1 += 1;
    }

    long value = https://www.cnblogs.com/liuyanling/p/0L;

    long get() {
        synchronized (new Object()) {
            return value;
        }
    }

第一段錯誤原因：
因為我們說過synchronized修飾普通方法 鎖定的是當前實體物件 this 而修飾靜態方法 鎖定的是當前類的 Class 物件
所以這里有兩把鎖 分別是 this 和 TestSynchronized3.class
由于臨界區 get() 和 addOne() 是用兩個鎖保護的，因此這兩個臨界區沒有互斥關系，臨界區 addOne() 對 value 的修改對臨界區 get() 也沒有可見性保證，這就導致并發問題了，

第二段錯誤原因：
加鎖本質就是在鎖物件的物件頭中寫入當前執行緒id，但是synchronized (new Object())每次在記憶體中都是新物件，所以加鎖無效，

問：剛剛的例子都是多個鎖保護一個資源，這樣百分百是不行的，那么一個鎖保護多個資源，就一定可以了嗎？

答：如果多個資源彼此之間是沒有關聯的，那可以用一個鎖來保護，如果有關聯的話，那是不行的，比如說銀行轉賬操作，你給我轉賬，我賬戶多100，你賬戶少100，我不能用我的鎖來保護你，就像現實生活中我的鎖是不能保護你的財產的，

劃重點！要區分多個資源是否有關聯！但是一個鎖保護多個沒關聯的資源，未免性能太差了哦，比如我聽歌和玩游戲可以同時進行，你非得讓我做完一個再做另一個，豈不是要雙倍時間，所以即使一個鎖可以保護多個沒關聯的資源，但是一般而已，會各自用不同的鎖，能夠提升性能，這種鎖還有個名字，叫細粒度鎖，

問：剛剛說到銀行轉賬的案例，那么假如某天在某銀行同時發生這樣一個事，柜員小王需要完成A賬戶給B賬戶轉賬100元，柜員小李需要完成B賬戶給A賬戶轉賬100元，請問如何實作呢？

答：其實用兩把鎖就實作了，轉出一把，轉入另一把，只有當兩者都成功時，才執行轉賬操作，

    public static void main(String[] args) throws InterruptedException {
        Account a = new Account(200); //A的初始賬戶余額200
        Account b = new Account(300); //B的初始賬戶余額200
        Thread threadA = new Thread(()->{
            try {
                transfer(a,b,100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread threadB = new Thread(()->{
            try {
                transfer(b,a,100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        threadA.start();
        threadB.start();
    }

    static void transfer(Account source,Account target, int amt) throws InterruptedException {
        synchronized (source) {
            log.info("持有鎖{} 等待鎖{}",source,target);
            synchronized (target) {
                if (source.getBalance() > amt) {
                    source.setBalance(source.getBalance() - amt);
                    target.setBalance(target.getBalance() + amt);
                }
            }
        }
    }

至此，恭喜你，一波問題解決了，可是遺憾的告訴你：又導致了另一個bug，這段代碼是有可能發生死鎖的！并發編程中要注意的東西可真是多喲，咱們先把死鎖這個名詞記住！持續關注【胖滾豬學編程】公眾號！在我們后面的文章中找答案！

如何保證原子性

現在我們已經知道互斥鎖可以保證原子性，也知道了如何使用synchronized來保證原子性，但synchronized 并不是JAVA中唯一能保證原子性的方案，

如果你粗略的看一下J.U.C(java.util.concurrent包)，那么你可以很顯眼的發現它倆：

一個是lock包，一個是atomic包，只要你英語過了四級，，我相信你都可以馬上斷定，它們可以解決原子性問題，

由于這兩個包比較重要，所以會放在后面的模塊單獨說，持續關注【胖滾豬學編程】公眾號吧！

本文轉載自公眾號【胖滾豬學編程】 用漫畫讓編程so easy and interesting！歡迎關注！形象來源于微信表情包【胖滾家族】喜歡可以下載哦~

標籤：大數據

上一篇：流媒體與實時計算，Netflix公司Druid應用實踐

下一篇：RDD和DataFrame和DataSet三者間的區別