關於synchronized的參數及其含義

Posted on by

這個想必大傢都不陌生，java裡面的重量級鎖。用來控制線程安全的。在long And long ，我剛開始接觸java的時候 ，我就對這個關鍵詞好奇頗深。尤其是 它的參數，有this的 也有靜態變量的。網上對這個參數解釋又太過術語話。

例如

作用於方法時，鎖住的是對象的實例(this)；

當作用於靜態方法時，鎖住的是Class實例，又因為Class的相關數據存儲在永久帶PermGen（jdk1.8則是metaspace），永久帶是全局共享的，因此靜態方法鎖相當於類的一個全局鎖，會鎖所有調用該方法的線程；

當作用於一個靜態類的時候，不管是不是本身內部的靜態類，還是別人的靜態類，都可以完成鎖住的效果（ps 上鎖的時候，相當於一群人 拿把鎖找個東西上鎖

synchronized作用於一個對象實例時，鎖住的是所有以該對象為鎖的代碼塊。

這不管是對於初學者，還是老鳥 。都感覺沉長無味。

最近，我的項目涉及到這一塊，我對這個方法有瞭頓悟，寫下來 傳之後世

我對這個參數的理解是這樣的。

synchronized(獲取鎖的地方){
工作內容
}

是的 ，你們沒看錯 （）裡面的就是一個“獲取鎖的地方”。{ }裡面是工作內容。 他們有這幾條關系。

  • 獲取鎖的地方 和 工作內容 是不必需要 有任何關聯的。 可以有關聯，但沒有關聯 也沒事
  • 獲取鎖的地方 ：隻是一個讓synchronized 整體 放置鎖的地方，一個“獲取鎖的地方” 隻有一把鎖。**
  • 工作內容： 要進行工作的**前提是 synchronized整體，找到一個“獲取鎖的地方”，在 “獲取鎖的地方” 獲取到瞭鎖， 如果 “獲取鎖的地方”的鎖，已經被別人拿去瞭，那麼就隻能等待別人 把鎖還給 “獲取鎖的地方”。然後 再獲取鎖。
  • synchronized 會使用運行工作內容的前提，必須獲取到鎖。這個意思呢，就是例如，當前線程synchronized 獲取到瞭objec A的鎖，那麼其他線程還可以更改 A 進行操作麼?。 這個得到分兩種情況，如果其他線程代碼 是被synchronized 所包裹的，那麼隻能等 objec A被釋放瞭，才能更改。如果，其他線程代碼沒有被synchronized包裹，她可以不需要有鎖，就可以對objec A進行操作。

解釋

先打個比方，我們把 synchronized這個看成一個整體，那麼在多線程的時候，就會有很多個 synchronized整體。 這個整體開始工作的前提是 它可以從 “獲取鎖的地方”拿到鎖。那麼他就可以做工作瞭。如果 想要 “獲取鎖的地方”的鎖，已經被別人拿走瞭。那麼隻能等別人把鎖換回來，才行。。

上面這個還是有點抽象。就這麼說吧 在程序運行多線程的，會產生好多synchronized整體。就叫小明，小紅，小芳，小花…等。他們現在手中沒有鎖，隻有手中有鎖的時候 才可以工作。 現在小明，小紅他們來到工作的地方。獲取鎖的地方就是路邊的一棵樹：：註意現在路邊隻有這一棵樹。小紅搶先一步將樹上的鎖拿走瞭。然後小紅工作去瞭（她的工作 不用和樹有關系，她可以砍樹，也可以去路邊掃地 ）。小明，小芳等其他人，因為沒地方獲取鎖（隻有一棵樹 並且樹的鎖 已經被小紅拿走瞭）。所以隻能在原地等待 ，小紅工作做完瞭 把鎖還給樹 ，小明，小芳才有機會進行工作。、

註意： 上面是路邊隻有一棵樹，如果存在好幾顆樹的話，那麼小明，小紅他們就可以同時放置獲取鎖 一個數對應一個鎖，多個樹就多個鎖。這個對應於類的實例 （實例可以有好多個）

在這裡插入圖片描述

驗證

我們首先定義一個Runnable ，因為 多線程的話 最好還是用Runnable,至於為什麼呢？百度去。

  static class LockRunable implements Runnable {
        private int num;
        private LockNormal lockNormal;
        public LockRunable(int num, LockNormal lockNormal) {
            this.num = num;
            this.lockNormal = lockNormal;
        }
        @Override
        public void run() {
            while (true) {

                    if (num <= 0) {
                        break;
                    }
                    try {
                        Thread.sleep(5);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "    " + num--);

            }
        }
    }

這個類呢 接受一個整數，一個LockNormal我自己定義的類，在run裡面呢先對 num進行判斷小於等於0的話，就退出，否則減一。 運行一下

  LockNormal lockNormal = new LockNormal();
        LockRunable one = new LockRunable(15, lockNormal);
        new Thread(one).start();
        new Thread(one).start();
        new Thread(one).start();
        new Thread(one).start();
        new Thread(one).start();

在這裡插入圖片描述

num竟然變成負的瞭，這是因為 五個線程同時對他進行操作，造成的。要避免這種情況，隻能一個線程操作的時候，別的線程就不能操作。

我們給程序加鎖試一下。首先定義一個 靜態成員，靜態成員有一個特點是系統初始化的，全局隻有一個實例。就相當於上面的 隻有一棵樹。

static final transient Object lock = new Object();

對 工作內容加鎖

    @Override
        public void run() {
            while (true) {
                synchronized (lock) {
                    if (num <= 0) {
                        break;
                    }
                    try {
                        Thread.sleep(5);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "    " + num--);
                }
            }
        }
    }

運行

在這裡插入圖片描述

這次就和預期結果相等瞭。但是 我們可發現 都是都是同一個線程進行操作的，這是因為 sleep時候不會釋放鎖，其他線程也無法進行操作

傳入實例

    static class LockRunable implements Runnable {

        private int num;

        private LockNormal lockNormal;

        public LockRunable(int num, LockNormal lockNormal) {
            this.num = num;
            this.lockNormal = lockNormal;
        }

        @Override
        public void run() {
            while (true) {
                synchronized (lockNormal) {
                    if (num <= 0) {
                        break;
                    }
                    try {
                        Thread.sleep(5);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "    " + num--);
                }
            }
        }
    }

結果：

在這裡插入圖片描述

也是同樣的結果，如果 我們傳入this的話 運行還是一樣的結果。這就是上面樹的問題瞭，不管是傳入的實例，還是this本身實例。隻有能保證它們本身是唯一的，也就是“獲取鎖的地方”隻有一個，同一時間內隻有一個人能成功獲取到鎖 進行工作。就和鎖靜態成員是一樣的效果如果我們 new 兩個Runnable的話，並且傳入this實例的話，就會有兩個“獲取鎖的地方” ，可以有兩個人同時工作。

總結

synchronized(放鎖的地方){
工作內容
}

隻要我們保證“獲取鎖的地方”是唯一的，那麼在同一時刻，就隻能有一個工作內容會被執行。如果，“獲取鎖的地方”不是唯一的（一個類new很多實例，鎖住this實例，那麼同一時刻就會有很多放鎖的地方），在同一時刻就會有好多 工作內容被執行。

以上為個人經驗，希望能給大傢一個參考，也希望大傢多多支持WalkonNet。

推薦閱讀：