volatile和Synchronized-CSDN博客

本文链接：https://blog.csdn.net/weixin_43604021/article/details/119455158

文章目录

- - volatile和Synchronized

volatile和Synchronized

并发编程的三个重要特性：

原子性 : 一个的操作或者多次操作，要么所有的操作全部都得到执行并且不会收到任何因素的干扰而中断，要么所有的操作都执行，要么都不执行。synchronized 可以保证代码片段的原子性。
可见性 ：当一个变量对共享变量进行了修改，那么另外的线程都是立即可以看到修改后的最新值。volatile 关键字可以保证共享变量的可见性。
有序性 ：代码在执行的过程中的先后顺序，Java 在编译器以及运行期间的优化，代码的执行顺序未必就是编写代码时候的顺序。volatile 关键字可以禁止指令进行重排序优化。

volatile的两个重要作用：

保证变量在多线程间的可见性；防止指令重排

可见性：

为什么需要volatile保证可见性？

我们需要简单了解一下我们CPU的内存模型，我们知道在计算机执行程序的时候，指令都是在CPU中执行的，但是我们的数据是存储在计算机的主内存中（物理内存）的。这就是导致一个不可避免的问题，就是内存的读取和写入的速度与CPU的执行指令速度相比差距是很大的，这样就会造成了与内存交互时程序执行效率大大降低，因此在CPU中就设计了高速缓存。

在这里插入图片描述

这个高速缓存解决了效率的问题，带来了准确度的问题？即缓存一致性问题。

就是我们CPU在执行的时候，会把主内存中的数据复制一份到我们的CPU高速缓存中去，如果我们有多个线程去执行一个程序，那么我们每个线程都复制了一份到高速缓存中，如我们现在有二个线程去执行一个程序，目的是每个线程把 num 的值加 1 ，num 的默认值是 0，结果应该是 num=2，但是可能有这种情况，我们的线程1 把 num=0 存入高速缓存中，进行加 1，现在线程1高速缓存中的 num=1，但是线程还没写入主内存中，主内存中还是num=0，线程2又把 num=0 存入高速缓存中，进行加1，现在线程2高速缓存中的也 num=1，然后线程1高速缓存写入主内存，主存中 num=1，然后线程2高速缓存写入主内存，主内存还是 num=1。

所以需要volatile来保证一致性。工作原理：

假设我们线程1运行将其加 1，num=1了，这时因为加了volatile关键字，我们线程1的高速缓存会立即写入主内存中（注意：我们该线程不仅会将volatile关键字修饰的变量立即写入主内存，还会把当前线程（方法）中所有可见的变量立即写入主内存中），并且通过我们其他的线程 num 的值被我改啦，你们之前拿到的值都不可能用啦，去主内存中重新取下值吧。

然后到我们线程2运行，因为收到了通知，其高速缓存的 num=0 已失效，不能用啦，就又去主存中又去了一次，num=1，然后对其加1，num=2，并将其写入主存中，也会通知其他线程 num 的值又被改啦。

顺序性：

我们 volatile关键字还有一个作用，就是禁止指令重排序，也就是我们上面说的保证其有序性，有序性：即程序执行的顺序按照代码的先后顺序执行。

指令重排：在Java内存模型中，允许编译器和处理器对指令进行重排序，但是重排序过程不会影响到单线程程序的执行，在单线程下有着一个 as-if-serial 的概念。

单线程模式下指令重排不会有问题，因为其遵守不管怎么重排，结果不能改变原则(as-if-seria)。

但是多线程下指令重排有可能出问题：

//线程1
while (a < b){
}
return b;

//线程2
a = 8;
b = 1;

在线程2正常不进行指令重排序的情况下，线程1跳出while循环时的值，可能是 a=8 , b=5 ，那么返回值可能是b=5

但是如果线程2发生了指令重排序的情况，这里线程1跳出while循环时的值，可能是 a=3 , b=1，那么返回值可能是b=1

Synchronized的两个作用:

保证操作的原子性和数据的可见性。

可见性：synchronized关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。

原子性：synchronized修饰的代码或者方法执行具有原子性。

为什么说synchronized属于重量级锁？

因为监视器锁（monitor）是依赖于底层的操作系统的 Mutex Lock 来实现的，Java 的线程是映射到操作系统的原生线程之上的。如果要挂起或者唤醒一个线程，都需要操作系统帮忙完成，而操作系统实现线程之间的切换时需要从用户态转换到内核态，这个状态之间的转换需要相对比较长的时间，时间成本相对较高。但是java6之后已经进行了优化。

synchronized的使用方式：

1.修饰实例方法：在实例对象上加锁，进入代码块要获得当前实例的锁

synchronized void method() { //业务代码 }

2.修饰静态方法: 也就是给当前类加锁，会作用于类的所有对象实例，进入同步代码前要获得 当前 class 的锁。因为静态成员不属于任何一个实例对象，是类成员（ static 表明这是该类的一个静态资源，不管 new 了多少个对象，只有一份）。所以，如果一个线程 A 调用一个实例对象的非静态 synchronized 方法，而线程 B 需要调用这个实例对象所属类的静态 synchronized 方法，是允许的，不会发生互斥现象，因为访问静态 synchronized 方法占用的锁是当前类的锁，而访问非静态 synchronized 方法占用的锁是当前实例对象锁

synchronized static void method() { //业务代码 }

3.修饰代码块：指定加锁对象，对给定对象/类加锁。synchronized(this|object) 表示进入同步代码库前要获得给定对象的锁。synchronized(类.class) 表示进入同步代码前要获得 当前 class 的锁

synchronized(this) { //业务代码 }

synchronized关键字的底层原理

1.同步语句块

public class SynchronizedDemo {
    public void method() {
        synchronized (this) {
            System.out.println("synchronized 代码块");
        }
    }
}

通过 JDK 自带的 javap 命令查看 SynchronizedDemo 类的相关字节码信息：首先切换到类的对应目录执行 javac SynchronizedDemo.java 命令生成编译后的 .class 文件，然后执行javap -c -s -v -l SynchronizedDemo.class。

在这里插入图片描述

从上面我们可以看出：

**synchronized 同步语句块的实现使用的是 monitorenter 和 monitorexit 指令，其中 monitorenter 指令指向同步代码块的开始位置，monitorexit 指令则指明同步代码块的结束位置。**当执行 monitorenter 指令时，线程试图获取锁也就是获取 对象监视器 monitor 的持有权。

wait/notify等方法也依赖于monitor对象，这就是为什么只有在同步的块或者方法中才能调用wait/notify等方法，否则会抛出java.lang.IllegalMonitorStateException的异常的原因。

2.修饰方法

public class SynchronizedDemo2 {
    public synchronized void method() {
        System.out.println("synchronized 方法");
    }
}

在这里插入图片描述

synchronized 修饰的方法并没有 monitorenter 指令和 monitorexit 指令，取得代之的确实是 ACC_SYNCHRONIZED 标识，该标识指明了该方法是一个同步方法。JVM 通过该 ACC_SYNCHRONIZED 访问标志来辨别一个方法是否声明为同步方法，从而执行相应的同步调用。

不过两者的本质都是对对象监视器 monitor 的获取。