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

例如

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

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

當作用于一個靜態(tài)類的時候，不管是不是本身內部的靜態(tài)類，還是別人的靜態(tài)類，都可以完成鎖住的效果（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竟然變成負的了，這是因為 五個線程同時對他進行操作，造成的。要避免這種情況，只能一個線程操作的時候，別的線程就不能操作。

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

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--);
                }
            }
        }
    }

運行

這次就和預期結果相等了。但是 我們可發(fā)現 都是都是同一個線程進行操作的，這是因為 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本身實例。只有能保證它們本身是唯一的，也就是“獲取鎖的地方”只有一個，同一時間內只有一個人能成功獲取到鎖 進行工作。就和鎖靜態(tài)成員是一樣的效果如果我們 new 兩個Runnable的話，并且傳入this實例的話，就會有兩個“獲取鎖的地方” ，可以有兩個人同時工作。

總結

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

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

以上為個人經驗，希望能給大家一個參考，也希望大家多多支持腳本之家。

最新評論