Android-Java-synchronized同步代碼塊的使用場景

synchronized同步代碼塊的使用場景 （滿足以下兩種條件，就要考慮使用synchronize同步代碼塊了）

 

1.被synchronized同步代碼塊{同步的代碼}，是被多次異步調用，什么叫多次異步調用？ 例如：多線程，........（例如：getValue()）

  1.多次異步調用之--多線程案例：

package android.java.thread09;

public class Test5 implements Runnable {

    // 共享數據
    int sum = 8;

    @Override
    public void run() {

        while (true) {

            synchronized (Test5.class) {

                if (sum > 0) {
                    System.out.println("sum:" + sum);
                    sum -- ;
                }
            }
        }

    }

    public static void main(String[] args) {
        /**
         * 定義Runnable實現類Test5，此實現類Test5不是線程，此實現類Test5給四個Thread去執行的
         */
        Runnable test5 = new Test5();

        // 實例化線程對象
        Thread thread1 = new Thread(test5); // 此實現類Test5給Thread去執行的
        Thread thread2 = new Thread(test5); // 此實現類Test5給Thread去執行的
        Thread thread3 = new Thread(test5); // 此實現類Test5給Thread去執行的
        Thread thread4 = new Thread(test5); // 此實現類Test5給Thread去執行的

        // 開啟啟動線程
        thread1.start(); // 啟動第Thread-0線程
        thread2.start(); // 啟動第Thread-1線程
        thread3.start(); // 啟動第Thread-2線程
        thread4.start(); // 啟動第Thread-3線程

        // 以上開啟了四個線程 屬於多線程了
    }
}

 

   2.多次異步調用之--方法被其他地方多次調用

package android.java.thread09;

public class Test6 {
    
    public  synchronized int getValue() {
        int count = 0 /* 假設有着具體負責也業務邏輯運算取值等操作 */;
        // ......
        return 0;
    }
    
}

 

屬於多次異步調用

例如：getValue(); 會被很多地方調用，是不是有可能出現同時調用的，就會出現安全問題，所以安全問題不僅僅出現在多線程，還出現在這種情況

 

---

 

 

 

2.多線程或......只持有一把鎖🔒是正確的✅， 多線程或...... 如果持有多個鎖🔒是錯誤的❌，那synchronized同步代碼塊毫無意義，而且還會浪費性能

  多線程或......只持有一把鎖🔒是正確的✅（案例一）（Test2.class鎖🔒 是一把鎖， 這就證明了多線程只持有一把鎖🔒是正確的✅）

package android.java.thread09;

public class Test2 implements Runnable {

    // 共享數據
    int sum = 8;

    @Override
    public void run() {

        while (true) {

            /** Test2.class 認為是一個鎖🔒，這個鎖是Jav內部要去判斷用的，屬於隱士的 看不到的
             *  Java內部的實現屬於 🔒鎖機制
             */
            synchronized (Test2.class) {

                if (sum > 0) {
                    System.out.println("sum:" + sum);
                    sum -- ;
                }
            }
        }

    }

    public static void main(String[] args) {
        /**
         * 定義Runnable實現類Test2，此實現類Test2不是線程，此實現類Test2給四個Thread去執行的
         */
        Runnable test2 = new Test2();

        // 實例化線程對象
        Thread thread1 = new Thread(test2); // 此實現類Test2給Thread去執行的
        Thread thread2 = new Thread(test2); // 此實現類Test2給Thread去執行的
        Thread thread3 = new Thread(test2); // 此實現類Test2給Thread去執行的
        Thread thread4 = new Thread(test2); // 此實現類Test2給Thread去執行的

        // 開啟啟動線程
        thread1.start(); // 啟動第Thread-0線程
        thread2.start(); // 啟動第Thread-1線程
        thread3.start(); // 啟動第Thread-2線程
        thread4.start(); // 啟動第Thread-3線程

        // 以上開啟了四個線程 屬於多線程了
    }
}

 

　多線程或......只持有一把鎖🔒是正確的✅（案例二）（object鎖🔒 是一把鎖， 這就證明了多線程只持有一把鎖🔒是正確的✅）

package android.java.thread09;

public class Test3 implements Runnable {

    // 共享數據
    int sum = 8;

    // 這個Object對象也是共享數據
    /**
     * 定義一個鎖🔒，此鎖🔒是共享的，這個鎖是Java內部要去判斷用的，屬於隱士的 看不到的
     * Java內部的實現屬於 🔒鎖機制
     */
    Object object = new Object();

    @Override
    public void run() {

        while (true) {

            synchronized (object) {

                if (sum > 0) {
                    System.out.println("sum:" + sum);
                    sum -- ;
                }
            }
        }

    }

    public static void main(String[] args) {
        /**
         * 定義Runnable實現類Test3，此實現類Test3不是線程，此實現類Test3給四個Thread去執行的
         */
        Runnable test3 = new Test3();

        // 實例化線程對象
        Thread thread1 = new Thread(test3); // 此實現類Test3給Thread去執行的
        Thread thread2 = new Thread(test3); // 此實現類Test3給Thread去執行的
        Thread thread3 = new Thread(test3); // 此實現類Test3給Thread去執行的
        Thread thread4 = new Thread(test3); // 此實現類Test3給Thread去執行的

        // 開啟啟動線程
        thread1.start(); // 啟動第Thread-0線程
        thread2.start(); // 啟動第Thread-1線程
        thread3.start(); // 啟動第Thread-2線程
        thread4.start(); // 啟動第Thread-3線程

        // 以上開啟了四個線程 屬於多線程了
    }
}

 

   多線程或...... 如果持有多個鎖🔒是錯誤的❌，那synchronized同步代碼塊毫無意義，❌❌❌ 錯誤的示范：

package android.java.thread09;

public class Test4 implements Runnable {

    // 共享數據
    int sum = 8;

    @Override
    public void run() {

        while (true) {

            /**
             * 錯錯錯❌，四個線程(多線程) 各種持有一把鎖🔒(因為每個線程都會new Object())，毫無意義
             */
            synchronized (new Object()) {

                if (sum > 0) {
                    System.out.println("sum:" + sum);
                    sum -- ;
                }
            }
        }

    }

    public static void main(String[] args) {
        /**
         * 定義Runnable實現類Test4，此實現類Test4不是線程，此實現類Test4給四個Thread去執行的
         */
        Runnable test4 = new Test4();

        // 實例化線程對象
        Thread thread1 = new Thread(test4); // 此實現類Test4給Thread去執行的
        Thread thread2 = new Thread(test4); // 此實現類Test4給Thread去執行的
        Thread thread3 = new Thread(test4); // 此實現類Test4給Thread去執行的
        Thread thread4 = new Thread(test4); // 此實現類Test4給Thread去執行的

        // 開啟啟動線程
        thread1.start(); // 啟動第Thread-0線程
        thread2.start(); // 啟動第Thread-1線程
        thread3.start(); // 啟動第Thread-2線程
        thread4.start(); // 啟動第Thread-3線程

        // 以上開啟了四個線程 屬於多線程了
    }
}