并发线程中的 synchronized 理解

已于 2023-06-29 09:35:55 修改
阅读量430 收藏
点赞数
分类专栏： # Java 文章标签： java 开发语言 android
于 2023-06-25 17:34:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/T_double/article/details/105524479
版权

必备知识：

  • 并发的概述：体现的是在单位时间内可以处理多任务交替处理问题的能力（比如1s内支持处理100个线程，则它的并发数就是100）
  • 并发的问题：不同线程同时使用同一个资源（如对象等）并发生修改时会出现数据不一致的问题，强调的是线程的安全概念
  • synchronized关键字：内置锁，可修饰 方法（含静态方法和非静态方法）、代码块
  • 对象锁、类锁
  • 互斥访问：即 串行执行，无法同时执行
  • 同步访问：即 并行执行，互不影响

延伸知识：

  • 内置锁：每个锁都会有开锁和关锁的动作，而 synchronized 并不需要我们去处理开关动作，因为它的开关动作全部在 Jvm 内部完成的，即开锁关锁动作已经被内置到 jvm 中去，所以它叫 内置锁
  • 锁的本质：synchronized 锁的本质是 jvm 的 monitor 机制
  • 锁的作用：如果有一个对象拿了一个锁，其他对象也想拿这个锁就拿不到，即 互斥访问

目录

修饰方法

  • 修饰 非静态方法：对象锁
    public synchronized void blockFunc() {}
      在 java 的设计思想里面，如上方法，我们想使用它的话，就必须基于实例出来的对象进行 对象.blockFunc() 调用，在这里，synchronized 的作用范围是 对象，那么它就是一个 对象锁，所以上述方法等同于：
    public synchronized(this) void blockFunc() {}
  • 修饰 静态方法：类锁
    public static synchronized void blockFunc() {}
      而使用了 static 关键字修饰的如上方法即为 静态方法，在使用的过程中，我们只要能拿得到类，就可以通过 类.blockFunc() 直接使用，在这里，synchronized 的作用范围是 类，那么它就是一个 类锁，所以上述方法等同于：
    public static synchronized(class) void blockFunc() {}

修饰代码块

  • 对象锁 代码块
    public void blockCode() {
    synchronized (object) {
        //TODO coding
    }
}
      在这里， object 表示 对象，它可以是 this 、全局/局部 的 Object 等。当 synchronized 后面的 变量 是 对象 时，它是一个 对象锁。那么在并发场景中，同一 实例对象 被多线程使用时，如果这个 变量 是同一对象，这些代码将会发生 互斥访问 ，反之这个 变量 如果不是同一个对象，则可以 同步访问；同理，如果是不同实例对象被多线程使用，那么他们之间是不存在互斥关系的，所以必然是 同步访问
  • 类锁 代码块
    public void blockCode() {
    synchronized (class) {
        //TODO coding
    }
}
      因为 类 是 唯一 的，所以只要 synchronized 后面的 变量 使用的是 类，这时候它就是一个 类锁，类 既然是唯一，那么发生的也只能是 互斥访问。

结论

  对象锁 的特点：如果不同线程监视的是 同一个实例对象，那么就会发生 互斥访问，否则可以 同步访问。
  类锁 的特点：如果不同线程监视的是 同一个类（包含同一个类实例出来的不同对象），只要是使用了 类锁 的代码，那么 必然 是 互斥访问，与根据哪个实例出来的对象进行访问无关。
  判断是否 互斥的标准：锁 的 对象 是不是 同一个对象（该对象包括类和实例的对象），如果是 类，那么就 必然 是 互斥访问，如果是 实例对象，那么就需要区分是不是同一个 实例对象，如果是，那么就是 互斥访问，否则是 同步访问

示例说明

  接下来将基于上面的结论，以实际示例的输出结果进行论证：

  • 非静态方法的 对象锁

    public class DateBean {

    public synchronized void blockFunc1() { 
        System.out.println("DateBean.blockFunc1 被线程 " + Thread.currentThread().getName() + " 调用的开始时间:" + System.currentTimeMillis());
        try {
            Thread.sleep(10_000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("DateBean.blockFunc1 被线程 " + Thread.currentThread().getName() + " 调用的结束时间:" + System.currentTimeMillis());
    }
    
    public synchronized void blockFunc2() { 
        System.out.println("DateBean.blockFunc2 被线程 " + Thread.currentThread().getName() + " 调用的开始时间:" + System.currentTimeMillis());
        try {
            Thread.sleep(10_000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("DateBean.blockFunc2 被线程 " + Thread.currentThread().getName() + " 调用的结束时间:" + System.currentTimeMillis());
    }
    
}

    1. 强调使用相同对象访问 同一个方法：dateBean.blockFunc1()，发生 互斥访问

          public static void main(String[] args) {
    
        DateBean dateBean = new DateBean();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                dateBean.blockFunc1();
            }
        }, "AThread").start();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                dateBean.blockFunc1();
            }
        }, "BThread").start();
        
    }

      输出结果：
      DateBean.blockFunc1 被线程 AThread 调用的开始时间:1687388503658 —①
      DateBean.blockFunc1 被线程 AThread 调用的结束时间:1687388513671 —②
      DateBean.blockFunc1 被线程 BThread 调用的开始时间:1687388513671 —③
      DateBean.blockFunc1 被线程 BThread 调用的结束时间:1687388523683 —④

      输出现象：
      ① 输出，10s 之后 ② 和 ③ 同时输出，在过 10s 后 ④ 才输出

    2. 强调使用相同对象访问不同方法：dateBean.blockFunc1() 和 dateBean.blockFunc2()，发生 互斥访问

          public static void main(String[] args) {
    
        DateBean dateBean = new DateBean();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                dateBean.blockFunc1();
            }
        }, "AThread").start();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                dateBean.blockFunc2();
            }
        }, "BThread").start();
        
    }

      输出结果：
      DateBean.blockFunc1 被线程 AThread 调用的开始时间:1687414155667 —①
      DateBean.blockFunc1 被线程 AThread 调用的结束时间:1687414165668 —②
      DateBean.blockFunc2 被线程 BThread 调用的开始时间:1687414165668 —③
      DateBean.blockFunc2 被线程 BThread 调用的结束时间:1687414175670 —④

      输出现象：
      ① 输出，10s 之后 ② 和 ③ 同时输出，在过 10s 后 ④ 才输出

    1 和 2 的结论：
      被 synchronized 修饰的非静态方法，它的锁实质上是 对象锁 ，所以在不同线程中同时使用 同一个对象 访问被 synchronized 修饰的非静态方法时（无论是否同一个方法），则发生 互斥访问
    原理：
      该并发场景有且只有一个对象：dateBean，而 public synchronized void blockFunc() {} 中的 synchronized 是一个 对象锁，它的作用范围是 dateBean 对象，所以当 AThread 持有该 对象锁 时，其他并发线程就无法持有，那么就只能等待，直到这个 对象锁 被释放后，线程 BThread 持有了它之后才能执行方法内的相关逻辑。
    通俗的理解：
      比如现在只有一辆自行车，但是想骑车的有 A、B 两人，那么这个时候 A 正使用这辆自行车在骑行，B 就只能等着，直到 A 骑完并归还了自行车，B才能使用这辆自行车进行骑行。

    1. 强调使用 不同 对象的访问同一个方法：dateBeanA.blockFunc1() 和 dateBeanB.blockFunc1() ，发生 同步访问 （不同对象访问不同方法就留给读者自己去思考和验证吧）

      public static void main(String[] args) {

    DateBean dateBeanA = new DateBean();
    DateBean dateBeanB = new DateBean();
    
    new Thread(new Runnable() {
        @Override
        public void run() {
            dateBeanA.blockFunc1();
        }
    }, "AThread").start();
    
    new Thread(new Runnable() {
        @Override
        public void run() {
            dateBeanB.blockFunc1();
            //dateBeanB.blockFunc2();
        }
    }, "BThread").start();
    
}

      输出结果：不同对象访问同一方法
      DateBean.blockFunc1 被线程 AThread 调用的开始时间:1687389856884 —①
      DateBean.blockFunc1 被线程 BThread 调用的开始时间:1687389856884 —②
      DateBean.blockFunc1 被线程 AThread 调用的结束时间:1687389866890 —③
      DateBean.blockFunc1 被线程 BThread 调用的结束时间:1687389866890 —④
      或者：不同对象访问不同方法
      DateBean.blockFunc1 被线程 AThread 调用的开始时间:1687417037316 —①
      DateBean.blockFunc2 被线程 BThread 调用的开始时间:1687417037316 —②
      DateBean.blockFunc1 被线程 AThread 调用的结束时间:1687417047322 —③
      DateBean.blockFunc2 被线程 BThread 调用的结束时间:1687417047322 —④

      输出现象：
      ① 和 ② 同时输出，10s 之后 ③ 和 ④ 同时输出

    3 的结论：
      结合 1 和 2 的结论，在不同线程中同时使用同一个类的 不同实例对象 访问被 synchronized 修饰的非静态方法时（无论是否同一个方法），发生的是 同步访问，它们各自执行各自的逻辑代码，彼此之间 互不影响。
    原理：
      该并发场景出现了 两个对象，分别是 dateBeanA 和 dateBeanB ，线程 AThread 持有的是 dateBeanA 的 对象锁，线程 BThread 持有的是 dateBeanB 的对象锁，它们可以同时拥有各自的 锁，所以彼此之间 互不影响
    通俗的理解：
      好比现在有两辆自行车，分别分配给想骑车的 A、B 两人，那么A、B想完成骑行这件事情时，只需要各自使用自己拥有的自行车就可以完成，两者之间互不影响。

  • 静态方法的 类锁

    public class DateBean {

    public static synchronized void blockFunc1() { 
        System.out.println("DateBean.blockFunc1 被线程 " + Thread.currentThread().getName() + " 调用的开始时间:" + System.currentTimeMillis());
        try {
            Thread.sleep(10_000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("DateBean.blockFunc1 被线程 " + Thread.currentThread().getName() + " 调用的结束时间:" + System.currentTimeMillis());
    }
    
    public static synchronized void blockFunc2() { 
        System.out.println("DateBean.blockFunc2 被线程 " + Thread.currentThread().getName() + " 调用的开始时间:" + System.currentTimeMillis());
        try {
            Thread.sleep(10_000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("DateBean.blockFunc2 被线程 " + Thread.currentThread().getName() + " 调用的结束时间:" + System.currentTimeMillis());
    }
    
}

    输出结果：
    DateBean.blockFunc1 被线程 AThread 调用的开始时间:1687414155667 —①
    DateBean.blockFunc1 被线程 AThread 调用的结束时间:1687414165668 —②
    DateBean.blockFunc1 被线程 BThread 调用的开始时间:1687414165668 —③
    DateBean.blockFunc1 被线程 BThread 调用的结束时间:1687414175670 —④
    或者：
    DateBean.blockFunc1 被线程 AThread 调用的开始时间:1687414155667 —①
    DateBean.blockFunc1 被线程 AThread 调用的结束时间:1687414165668 —②
    DateBean.blockFunc2 被线程 BThread 调用的开始时间:1687414165668 —③
    DateBean.blockFunc2 被线程 BThread 调用的结束时间:1687414175670 —④

    输出现象：
    ① 输出，10s 之后 ② 和 ③ 同时输出，在过 10s 后 ④ 才输出

    结论：
      以上类的静态方法经验证，无论是一个对象还是多个对象的任何组合访问，最终的输出结果均是一致：互斥访问。
    而出现这样一致的原因即为 synchronized 是一个 类锁，它是唯一的，与具体实例出多少对象是无关的

  • 代码块的 对象锁

    public static class DateBean {

    public void blockCode1() {
        synchronized (this) {
            System.out.println("DateBean.blockCode1 被线程 " + Thread.currentThread().getName() + " 调用的开始时间:" + System.currentTimeMillis());
            try {
                Thread.sleep(10_000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("DateBean.blockCode1 被线程 " + Thread.currentThread().getName() + " 调用的结束时间:" + System.currentTimeMillis());
        }
    }

    public void blockCode1_1() {
        synchronized (this) {
            System.out.println("DateBean.blockCode1_1 被线程 " + Thread.currentThread().getName() + " 调用的开始时间:" + System.currentTimeMillis());
            try {
                Thread.sleep(10_000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("DateBean.blockCode1_1 被线程 " + Thread.currentThread().getName() + " 调用的结束时间:" + System.currentTimeMillis());
        }
    }

    private Object object = new Object();
    public void blockCode2() {
        synchronized (object) {
            System.out.println("DateBean.blockCode2 被线程 " + Thread.currentThread().getName() + " 调用的开始时间:" + System.currentTimeMillis());
            try {
                Thread.sleep(10_000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("DateBean.blockCode2 被线程 " + Thread.currentThread().getName() + " 调用的结束时间:" + System.currentTimeMillis());
        }
    }

    public void blockCode2_2() {
        synchronized (object) {
            System.out.println("DateBean.blockCode2_2 被线程 " + Thread.currentThread().getName() + " 调用的开始时间:" + System.currentTimeMillis());
            try {
                Thread.sleep(10_000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("DateBean.blockCode2_2 被线程 " + Thread.currentThread().getName() + " 调用的结束时间:" + System.currentTimeMillis());
        }
    }
    	
    public void blockCode3() {
        Object mObject = new Object();
        synchronized (mObject) {
            System.out.println("DateBean.blockCode3 被线程 " + Thread.currentThread().getName() + " 调用的开始时间:" + System.currentTimeMillis());
            try {
                Thread.sleep(10_000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("DateBean.blockCode3 被线程 " + Thread.currentThread().getName() + " 调用的结束时间:" + System.currentTimeMillis());
        }
    }

    public void blockCode3_1() {
        Object mObject = new Object();
        synchronized (mObject) {
            System.out.println("DateBean.blockCode3_1 被线程 " + Thread.currentThread().getName() + " 调用的开始时间:" + System.currentTimeMillis());
            try {
                Thread.sleep(10_000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("DateBean.blockCode3_1 被线程 " + Thread.currentThread().getName() + " 调用的结束时间:" + System.currentTimeMillis());
        }
    }

    public void blockCode4() {
        Integer blockCodeObject = 127;
//        Integer blockCodeObject = 128;
        synchronized (blockCodeObject) {
            System.out.println("DateBean.blockCode4 被线程 " + Thread.currentThread().getName() + " 调用的开始时间:" + System.currentTimeMillis());
            try {
                Thread.sleep(10_000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("DateBean.blockCode4 被线程 " + Thread.currentThread().getName() + " 调用的结束时间:" + System.currentTimeMillis());
        }
    }
}

    1. 强调使用 相同 对象的 同一个方法：dateBean.blockCode1()，发生 互斥访问

      public static void main(String[] args) {

    DateBean dateBean = new DateBean();
    new Thread(new Runnable() {
        @Override
        public void run() {
            dateBean.blockCode1();
        }
    }, "AThread").start();

    new Thread(new Runnable() {
        @Override
        public void run() {
            dateBean.blockCode1();
        }
    }, "BThread").start();
}

      输出结果：
      DateBean.blockCode1 被线程 AThread 调用的开始时间:1687519230610 —①
      DateBean.blockCode1 被线程 AThread 调用的结束时间:1687519240612 —②
      DateBean.blockCode1 被线程 BThread 调用的开始时间:1687519240612 —③
      DateBean.blockCode1 被线程 BThread 调用的结束时间:1687519250616 —④

      输出现象：
      ① 输出，10s 之后 ② 和 ③ 同时输出，在过 10s 后 ④ 才输出

    2. 强调使用 相同 对象的 同一个方法：dateBean.blockCode2()，发生 互斥访问

      public static void main(String[] args) {

    DateBean dateBean = new DateBean();
    new Thread(new Runnable() {
        @Override
        public void run() {
            dateBean.blockCode2();
        }
    }, "AThread").start();

    new Thread(new Runnable() {
        @Override
        public void run() {
            dateBean.blockCode2();
        }
    }, "BThread").start();
}

      输出结果：
      DateBean.blockCode2 被线程 AThread 调用的开始时间:1687519525480 —①
      DateBean.blockCode2 被线程 AThread 调用的结束时间:1687519535481 —②
      DateBean.blockCode2 被线程 BThread 调用的开始时间:1687519535481 —③
      DateBean.blockCode2 被线程 BThread 调用的结束时间:1687519545491 —④

      输出现象：
      ① 输出，10s 之后 ② 和 ③ 同时输出，在过 10s 后 ④ 才输出

    3. 强调使用 相同 对象的 不同方法：dateBean.blockCode1() 和 dateBean.blockCode1_1()，发生 互斥访问

      public static void main(String[] args) {

    DateBean dateBean = new DateBean();
    new Thread(new Runnable() {
        @Override
        public void run() {
            dateBean.blockCode1();
        }
    }, "AThread").start();

    new Thread(new Runnable() {
        @Override
        public void run() {
            dateBean.blockCode1_1();
        }
    }, "BThread").start();
}

      输出结果：
      DateBean.blockCode1 被线程 AThread 调用的开始时间:1687519525480 —①
      DateBean.blockCode1_1 被线程 AThread 调用的结束时间:1687519535481 —②
      DateBean.blockCode1 被线程 BThread 调用的开始时间:1687519535481 —③
      DateBean.blockCode1_1 被线程 BThread 调用的结束时间:1687519545491 —④

      输出现象：
      ① 输出，10s 之后 ② 和 ③ 同时输出，在过 10s 后 ④ 才输出

    4. 强调使用 相同 对象的 不同方法：dateBean.blockCode2() 和 dateBean.blockCode2_2()，发生 互斥访问

      public static void main(String[] args) {

    DateBean dateBean = new DateBean();
    new Thread(new Runnable() {
        @Override
        public void run() {
            dateBean.blockCode2();
        }
    }, "AThread").start();

    new Thread(new Runnable() {
        @Override
        public void run() {
            dateBean.blockCode2_2();
        }
    }, "BThread").start();
}

      输出结果：
      DateBean.blockCode2 被线程 AThread 调用的开始时间:1687519525480 —①
      DateBean.blockCode2_2 被线程 AThread 调用的结束时间:1687519535481 —②
      DateBean.blockCode2 被线程 BThread 调用的开始时间:1687519535481 —③
      DateBean.blockCode2_2 被线程 BThread 调用的结束时间:1687519545491 —④

      输出现象：
      ① 输出，10s 之后 ② 和 ③ 同时输出，在过 10s 后 ④ 才输出

    1、2、3 和 4 的结论：
      因为 synchronized 的变量是 this 和 实例出来的全局变量（对象），所以这时候它是一个对象锁：this 代表的是 dateBean 对象，object 代表的是 dateBean 对象中的对象，在同一个 dateBean 中它也是唯一的。 所以被修饰的 方法块 的作用范围自然也是 对象，所以它就是 对象锁 ，那么在不同线程中同时对使用 同一个对象 的 同一个代码块 或者 不同代码块 进行访问时，则 发生了互斥访问。
    原理：
      该并发场景有且只有一个对象，那就是 dateBean ，而 blockCode() 方法中 synchronized (blockCodeObject) {} 方法块 的 synchronized 是一个 对象锁，它的作用范围就仅仅只是 dateBean 对象，所以当 AThread 持有该 对象锁 时，其他并发线程就无法持有，那么就只能等待，直到这个 对象锁 被释放后，线程 BThread 持有了它之后才能执行 方法块内 的相关的逻辑。
    通俗的理解：
      比如现在只有一辆自行车，但是想骑车的有 A、B 两人，那么这个时候 A 正使用这辆自行车在骑行，B 就只能等着，直到 A 骑完并归还了自行车，B才能使用这辆自行车进行骑行。

    1. 强调使用 相同 对象的不同方法：dateBean.blockCode2() 和 dateBean.blockCode3()，发生 同步访问

      public static void main(String[] args) {

    DateBean dateBean = new DateBean();
    
    new Thread(new Runnable() {
        @Override
        public void run() {
            dateBean.blockCode2();
        }
    }, "AThread").start();
    
    new Thread(new Runnable() {
        @Override
        public void run() {
            dateBean.blockCode3();
        }
    }, "BThread").start();
}

      输出结果：
      DateBean.blockCode2 被线程 AThread 调用的开始时间:1687676937120 —①
      DateBean.blockCode3 被线程 BThread 调用的开始时间:1687676937120 —②
      DateBean.blockCode2 被线程 AThread 调用的结束时间:1687676947133 —③
      DateBean.blockCode3 被线程 BThread 调用的结束时间:1687676947133 —④

      输出现象：
      ① 和 ② 同时输出，10s 之后 ③ 和 ④ 同时输出

    2. 强调使用 相同 对象的不同方法：dateBean.blockCode3() 和 dateBean.blockCode3_1()，发生 同步访问

      public static void main(String[] args) {

    DateBean dateBean = new DateBean();
    
    new Thread(new Runnable() {
        @Override
        public void run() {
            dateBean.blockCode3();
        }
    }, "AThread").start();
    
    new Thread(new Runnable() {
        @Override
        public void run() {
            dateBean.blockCode3_1();
        }
    }, "BThread").start();
}

      输出结果：
      DateBean.blockCode3 被线程 AThread 调用的开始时间:1687676937120 —①
      DateBean.blockCode4 被线程 BThread 调用的开始时间:1687676937120 —②
      DateBean.blockCode3 被线程 AThread 调用的结束时间:1687676947133 —③
      DateBean.blockCode4 被线程 BThread 调用的结束时间:1687676947133 —④

      输出现象：
      ① 和 ② 同时输出，10s 之后 ③ 和 ④ 同时输出

      5 和 6 的结论：
        不管 5（全局对象+局部对象） 还是 6（各自方法内的局部对象） 示例中，synchronized 的 变量 都不是同一个对象，所以它们之间发生的是 同步访问 。

    3. 同理，在强调使用 不同 对象的 同一个方法 或者 不同方法中，因为对象锁已经因为不同对象而不同了，所以发生的 同步访问

    4. 强调使用 相同 对象的 同一个方法：dateBean.blockCode4()
        在此，如果小伙伴足够细心的话，则会发现在 blockCode4() 中局部 常量对象 blockCodeObject 有两种赋值，分别是 127 和 128 ，目前 128 是被注释状态，这里并不是我忘记删掉，而是特意留着的一处风景：

      public static void main(String[] args) {

    DateBean dateBean = new DateBean();
    
    new Thread(new Runnable() {
        @Override
        public void run() {
            dateBean.blockCode4();
        }
    }, "AThread").start();
    new Thread(new Runnable() {
        @Override
        public void run() {
            dateBean.blockCode4();
        }
    }, "BThread").start();
}

      输出结果：Integer blockCodeObject = 127 异步访问
      DateBean.blockCode4 被线程 AThread 调用的开始时间:1687519525480 —①
      DateBean.blockCode4 被线程 AThread 调用的结束时间:1687519535481 —②
      DateBean.blockCode4 被线程 BThread 调用的开始时间:1687519535481 —③
      DateBean.blockCode4 被线程 BThread 调用的结束时间:1687519545491 —④

      输出现象：
      ① 输出，10s 之后 ② 和 ③ 同时输出，在过 10s 后 ④ 才输出

      输出结果：Integer blockCodeObject = 128 同步访问
      DateBean.blockCode4 被线程 AThread 调用的开始时间:1687676937120 —①
      DateBean.blockCode4 被线程 BThread 调用的开始时间:1687676937120 —②
      DateBean.blockCode4 被线程 AThread 调用的结束时间:1687676947133 —③
      DateBean.blockCode4 被线程 BThread 调用的结束时间:1687676947133 —④

      输出现象：
      ① 和 ② 同时输出，10s 之后 ③ 和 ④ 同时输出

      结论：
        blockCode4() 的并发情况会因为 Integer 的值而发生差异结果，原因在于 Integer 的取值范围是 -128 - 127，在这个范围内，它是一个常量值，它存在于一个常量池中，所有 Integer 值都指向该池中的同一个常量，所以实质上是同一个对象，所以发生的是 互斥访问；当 Integer 值为 128 时，它实际执行的是一个 new 动作申请出来的对象，那么每次执行 new 动作时候，虽然值都是 128，但是它们并不是相同对象，所以发生了 同步访问

  • 代码块的 类锁

叫我Aso
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浅析java并发中的Synchronized关键词
08-25
Java并发编程中，Synchronized关键词是一个非常重要的概念，它提供了一种简单而又有效的方法来实现线程安全。在多线程环境中，Synchronized关键词可以用来保护共享资源，使得同一时间只有一个线程可以访问某个资源...
Java多线程并发编程 Synchronized关键字
08-30
Java中的`synchronized`关键字是多线程编程中用于实现线程同步的重要机制，它确保了在多线程环境下对共享资源的访问具有互斥性和可见性。这些特性使得`synchronized`成为解决并发问题的关键工具。 1. **同步锁机制*...
深入分析Synchronized原理(阿里面试题)
09-06 387
还有一篇 讲解lock的实现原理，参考：解决多线程安全问题-无非两个方法synchronized和lock 具体原理以及如何 获取锁AQS算法 (百度-美团) 还有一篇写的不错：深入理解synchronized底层原理，一篇文章就够了！ 另一篇少的：synchronize原理 记得开始学习Java的时候，一遇到多线程情况就使用synchronized，相对于当时的我们来说synch...
Java中Synchronized的使用
程序员小强的博客
04-05 2万+
在编程中，经常需要用到同步，这里讲一下synchronized关键字的相关知识 1.使用方式 修饰一个代码块，被修饰的代码块称为同步代码块，作用范围是大括号{}括起来的代码； 修饰一个方法，被修饰的方法称为同步方法，其作用范围是整个方法； 修改一个静态方法，作用范围是整个静态方法； 修改一个类，作用范围是synchronized后面括号括起来的部分。 2.使用示例 修饰代码块 注：this 表...
第四篇：synchronized，并发安全的守护神
毛毛的专栏
11-22 561
文章目录一、前言二、synchronized的使用2.1 synchronized五种情况2.2 synchronized五种情况的使用2.2.1 synchronized五种情况的使用2.2.2 第一种情况和第三种情况2.2.3 第二种情况和第四种情况三、synchronized源码解析3.1 对象头 + Mark Word3.1.1 同步锁对象的对象头(对象头=Mark Word + Class Metadata Address + Array length，三个每一个占一个字宽)3.1.2 对象头的M
02 多线程与高并发 - synchronized 解析
刘元雄
07-29 293
02 多线程与高并发 - synchronized 解析
Java高并发之魂：synchronized深度解析
Just-For-Fun
07-18 170
一、概念 1. synchronized释义：    synchronized 中文释义使同步化。 2. 一句话说出synchronized的作用：    能够保证在同一时刻最多只有一个线程执行某段代码，以达到保证并发安全的效果。 二、代码演示 1. 不使用并发的后果：    案例：两个线程，同时分别对一条数据进行累加10万次。    结果：最终，i值小于20万。    结果分析：i++的过程可...
【多线程与高并发】- synchronized锁的认知
qq_43843951的博客
02-19 22万+
synchronized 是 Java 语言的一个关键字，它允许多个线程同时访问共享的资源，以避免多线程编程中的竞争条件和死锁问题。
深入理解Java并发之synchronized实现原理
热门推荐
zejian的博客
06-04 40万+
【版权申明】未经博主同意，谢绝转载！（请尊重原创，博主保留追究权） http://blog.csdn.net/javazejian/article/details/72828483 出自【zejian的博客】 关联文章： 深入理解Java类型信息(Class对象)与反射机制 深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深...
彻底理解Java并发：synchronized关键字
栗筝i的博客
10-29 4281
本篇内容包括：Synchronized 关键字简介、synchronized 的修饰对象、对象的内存布局（64位）、Synchronized 锁升级过程等内容。
Java——多线程高并发系列之synchronized关键字
★★光亭★★
06-06 6977
Java——多线程高并发系列之synchronized关键字
【多线程及高并发 番外篇】虚拟线程怎么被 synchronized 阻塞了？
若明天不见
12-25 2095
这系列文章讲述多线程及高并发详解，此文主要讲述虚拟线程概念、实现原理。在使用虚拟线程的过程中，synchronized 会导致虚拟线程阻塞的问题及原理分析
Java多线程中使用synchronized说明
12-22
在给出的示例中，`Stu`类的`read1()`和`read2()`方法都被声明为`synchronized`，因此当`StuThread1`和`StuThread2`并发运行时，它们会按照线程启动的顺序依次执行，因为它们都在争夺同一个对象（`stu`）的锁。...
Java 并发编程学习笔记之Synchronized简介
09-02
Java并发编程中的Synchronized关键字是Java提供的一种内置锁机制，用于解决多线程环境下的线程安全问题。在Java中，线程安全意味着多个线程访问同一份资源时，能够保持数据的一致性和完整性，避免数据冲突。...
Java线程安全synchronized
12-22
　并发编程的原则：设计并发编程的目的是为了使程序获得更高的执行效率，但绝不能出现数据一致性(数据准确)问题，如果并发程序连基本的执行结果准确性都无法保证，那并发编程没有任何意义。 　为什么会出现数据不...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 446
1.导入hutool的maven依赖。2.复制一下代码执行。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 244
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 620
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
花几千上万学习Java，真没必要！（三十五）
最新发布
wehpd的博客
07-30 278
集合之Map
Java JUC并发编程实例：守护线程与Synchronized锁
这个资源通过具体的代码实例，展示了Java多线程编程中的基础概念，包括如何使用用户线程和守护线程，以及如何利用JUC库中的同步机制（如`synchronized`和`Lock`）来处理并发场景中的数据一致性问题。这些知识对于有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值