Java中關鍵字synchronized的使用方法詳解

更新時間：2021年08月13日 09:23:20 作者：超新星燃燒

synchronized關鍵字可以作為函數(shù)的修飾符,也可作為函數(shù)內(nèi)的語句,也就是平時說的同步方法和同步語句塊,下面這篇文章主要給大家介紹了關于Java中synchronized使用的相關資料,需要的朋友可以參考下

synchronized是Java里的一個關鍵字，起到的一個效果是“監(jiān)視器鎖”~~，它的功能就是保證操作的原子性，同時禁止指令重排序和保證內(nèi)存的可見性！

public  class TestDemo {
    static  class Counter{
        public int count = 0;

        public void add(){
            count++;
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread t1 = new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 50000; i++) {
                    counter.add();
                }
            }
        };

        Thread t2 = new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 50000; i++) {
                    counter.add();
                }
            }
        };

        //啟動兩個線程
        t1.start();
        t2.start();
        //等待兩個線程結(jié)束
        t1.join();
        t2.join();
        System.out.println(counter.count);
    }
}

此時的線程就是不安全的，如何解決呢？

給我們的Counter對象里的add方法加上synchronized關鍵字，針對這個方法進行了加鎖操作。進入代碼塊(調(diào)用方法)自動加鎖，出了代碼塊(方法結(jié)束)，自動解鎖。

public  class TestDemo {
    static  class Counter{
        public int count = 0;
         
         //修飾方法
         synchronized public void add{
             count++;
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread t1 = new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 50000; i++) {
                    counter.add();
                }
            }
        };

        Thread t2 = new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 50000; i++) {
                    counter.add();
                }
            }
        };

        //啟動兩個線程
        t1.start();
        t2.start();
        //等待兩個線程結(jié)束
        t1.join();
        t2.join();
        System.out.println(counter.count);
    }
}

那么這里的代碼是如何保證正確的呢？

使用synchronized 就相當于在我們執(zhí)行的指令里又加入了2條新指令。

LOCK (加鎖)

UNLOCK （解鎖）

LOCK操作特性：只有一個線程能執(zhí)行成功！如果第一個線程執(zhí)行成功，第二個線程也嘗試LOCK，就會阻塞等待，直到第一個線程執(zhí)行UNLOCK 釋放鎖~

通過LOCK和UNLOCK 就把 LOAD ADD SAVE 這三個指令，給打包成了一個原子的操作(中間不能被打斷，也不能被其他線程穿插)。

這里的加鎖也是保證原子性的核心操作，所以線程里的沒組指令就會順序執(zhí)行，不在穿插執(zhí)行，就保證了線程1執(zhí)行完之后再去執(zhí)行線程2。

舉個例子：

就好比張三和李四去ATM里去取錢，當張三進去取錢時，進去后就會鎖門，李四就會在外面等待，直到張三取完錢出來后，李四在進去取錢。

synchronized 也會禁止編譯器進行“內(nèi)存可見性”和“指令重排序”的優(yōu)化~ 同時程序運行的效率就會降低，
也會導致線程之間相互去等待，就涉及到系統(tǒng)的一些調(diào)度，也會引入一些時間成本。

synchronized修飾的對象有以下幾種：

修飾一個代碼塊，被修飾的代碼塊稱為同步語句塊，其作用的范圍是大括號{}括起來的代碼，作用的對象是調(diào)用這個代碼塊的對象；

public class TestDemo{
    public void methond() {
        // 進入代碼塊會鎖 this 指向?qū)ο笾械逆i；
        // 出代碼塊會釋放 this 指向的對象中的鎖
        synchronized (this) {

        }
    }
    public static void main(String[] args) {
        TestDemo demo = new TestDemo();
        demo.methond();
    }
}

修飾一個方法，被修飾的方法稱為同步方法，其作用的范圍是整個方法，作用的對象是調(diào)用這個方法的對象；

public class TestDemo{
    public synchronized void methond() {

    }
    public static void main(String[] args) {
        TestDemo demo = new TestDemo();
        demo.methond();
        // 進入方法會鎖 demo 指向?qū)ο笾械逆i；
        // 出方法會釋放 demo 指向的對象中的鎖
    }
}

修改一個靜態(tài)的方法，其作用的范圍是整個靜態(tài)方法，作用的對象是這個類的所有對象；

public class TestDemo{
    public synchronized static void methond() {

    }
    public static void main(String[] args) {
        methond();
        // 進入方法會鎖 TestDemo.class 指向?qū)ο笾械逆i；
        //出方法會釋放 TestDemo.class 指向的對象中的鎖
    }
}

修改一個類，其作用的范圍是synchronized后面括號括起來的部分，作用主的對象是這個類的所有對象。

public class TestDemo{
    public static void methond() {
        // 進入代碼塊會鎖 TestDemo.class 指向?qū)ο笾械逆i；
        //出代碼塊會釋放 TestDemo.class 指向的對象中的鎖
        synchronized (TestDemo.class) {

        }
    }
    public static void main(String[] args) {
        TestDemo demo = new TestDemo();
        demo.methond();
    }
}

總結(jié)：

無論synchronized關鍵字加在方法上還是對象上，如果它作用的對象是非靜態(tài)的，則它取得的鎖是對象；
如果synchronized作用的對象是一個靜態(tài)方法或一個類，則它取得的鎖是對類，該類所有的對象同一把鎖。
每個對象只有一個鎖（lock）與之相關聯(lián)，誰拿到這個鎖誰就可以運行它所控制的那段代碼。
實現(xiàn)同步是要很大的系統(tǒng)開銷作為代價的，甚至可能造成死鎖，所以盡量避免無謂的同步控制。

拓展：

public  class TestDemo {

    static   class Counter{
        public int count = 0;

           public void add(){
               synchronized (this){
                   count++;
               }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread t1 = new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 50000; i++) {
                    synchronized (counter){
                        counter.add();
                    }
                }
            }
        };
        Thread t2 = new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 50000; i++) {
                    synchronized (counter){
                        counter.add();
                    }
                }
            }
        };

        //啟動兩個線程
        t1.start();
        t2.start();
        //等待兩個線程結(jié)束
        t1.join();
        t2.join();
        System.out.println(counter.count);
    }
}

此時可以看出上述代碼，加了兩次鎖，會發(fā)生什么呢？