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线程

        // 以上开启了四个线程 属于多线程了
    }
}