java synchronized实现可见性对比volatile

问题：

　大家可以先看看这个问题，看看这个是否有问题呢？那里有问题呢？

public class ThreadSafeCache {
    int result;
    
    public int getResult() {
        return result;
    }
    
    public synchronized void setResult(int result) {
        this.result = result;
    }
    
}

　　如果你在这个问题上面停留超过5s的话，那么表示你对这块某些知识还有点模糊，需要再巩固下，下面我们一起来分析下！

1. 结论

　　多线程并发的同时进行set、get操作，A线程调用set方法，B线程并不一定能对这个改变可见！！！

2. 分析　　

　　这个类非常简单，里面有一个属性，有2个方法：get、set方法，一个用来设置属性值，一个用来获取属性值，在设置属性方法上面加了synchronized。

　　隐式信息：多线程并发的同时进行set、get操作，A线程调用set方法，B线程可以里面感知到吗？？？

　　说到这里，问题就变成了synchronized在刚刚说的上下文下面能否保证可见性！！！

3. 关键词synchronized的用法

指定加锁对象:对给定对象加锁，进入同步代码前需要获得给定对象的锁。
直接作用于实例方法:相当于对当前实例加锁，进入同步代码前要获得当前实例的锁。
直接作用于静态方法:相当于对当前类加锁，进入同步代码前要获得当前类的锁。

　　synchronized它的工作就是对需要同步的代码加锁，使得每一次只有一个线程可以进入同步块（其实是一种悲观策略）从而保证线程之间得安全性。

从这里我们可以知道，我们需要分析的属于第二类情况，也就是说多个线程如果同时进行set方法的时候，由于存在锁，所以会一个一个进行set操作，并且是线程安全的，但是get方法并没有加锁，表示假如A线程在进行set的同时B线程可以进行get操作。并且可以多个线程同时进行get操作，但是同一时间最多只能有一个set操作。

4. Java 内存模型 happens-before原则　

　JSR-133 内存模型使用 happens-before 的概念来阐述操作之间的内存可见性。在 JMM 中，如果一个操作执行的结果需要对另一个操作可见，那么这两个操作之间必须要存在 happens-before 关系。这里提到的两个操作既可以是在一个线程之内，也可以是在不同线程之间。

　与程序员密切相关的 happens-before 规则如下：

程序顺序规则：一个线程中的每个操作，happens-before 于该线程中的任意后续操作。
监视器锁规则：对一个监视器的解锁，happens-before 于随后对这个监视器的加锁。
volatile 变量规则：对一个 volatile 域的写，happens-before 于任意后续对这个 volatile 域的读。
传递性：如果 A happens-before B，且 B happens-before C，那么 A happens-before C。

注意，两个操作之间具有 happens-before 关系，并不意味着前一个操作必须要在后一个操作之前执行！happens-before 仅仅要求前一个操作（执行的结果）对后一个操作可见，且前一个操作按顺序排在第二个操作之前（the first is visible to and ordered before the second）。

其中有监视器锁规则：对一个监视器的解锁，happens-before 于随后对这个监视器的加锁。这一条，仅仅只是针对synchronized的set方法，而对于get并没有这方面的说明。

其实在这种上下文下面一个synchronized的set方法，一个普通的get方法，a线程调用set方法，b线程并不一定能对这个改变可见！

5. volatile

volatile可见性
　　前面happens-before原则就提到：volatile 变量规则：对一个 volatile 域的写，happens-before 于任意后续对这个 volatile 域的读。volatile从而保证了多线程下的可见性！！！

volatile 禁止内存重排序
　　下面是 JMM 针对编译器制定的 volatile 重排序规则表：

java synchronized实现可见性对比volatile

　为了实现 volatile 的内存语义，编译器在生成字节码时，会在指令序列中插入内存屏障来禁止特定类型的处理器重排序。

　下面是基于保守策略的 JMM 内存屏障插入策略：

在每个 volatile 写操作的前面插入一个 StoreStore 屏障。
在每个 volatile 写操作的后面插入一个 StoreLoad 屏障。
在每个 volatile 读操作的后面插入一个 LoadLoad 屏障。
在每个 volatile 读操作的后面插入一个 LoadStore 屏障。

　下面是保守策略下，volatile 写操作插入内存屏障后生成的指令序列示意图：

java synchronized实现可见性对比volatile

　下面是在保守策略下，volatile 读操作插入内存屏障后生成的指令序列示意图：

java synchronized实现可见性对比volatile

　　上述 volatile 写操作和 volatile 读操作的内存屏障插入策略非常保守。在实际执行时，只要不改变 volatile 写-读的内存语义，编译器可以根据具体情况省略不必要的屏障。

　　双重检查锁实现单例中就需要用到这个特性！！！

6. 模拟

　　通过上面的分析，其实这个题目涉及到的内容都提到了，并且进行了解答。

虽然你知道的原因，但是想模拟并不是一件容易的事情！，下面我们来模拟看看效果：

public class ThreadSafeCache {
    int result;

    public int getResult() {
        return result;
    }

    public synchronized void setResult(int result) {
        this.result = result;
    }

    public static void main(String[] args) {
        ThreadSafeCache threadSafeCache = new ThreadSafeCache();

        for (int i = 0; i < 8; i++) {
            new Thread(() -> {
                int x = 0;
                while (threadSafeCache.getResult() < 100) {
                    x++;
                }
                System.out.println(x);
            }).start();
        }

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        threadSafeCache.setResult(200);
    }
}

效果：

java synchronized实现可见性对比volatile

　　程序会一直卡在这边不动，表示set修改的200，get方法并不可见！！！

添加volatile 关键词观察效果

　　其实例子中synchronized关键字可以去掉，仅仅用volatile即可。

java synchronized实现可见性对比volatile

效果：

java synchronized实现可见性对比volatile

代码很快正常结束了！

结论：多线程并发的同时进行set、get操作，A线程调用set方法，B线程并不一定能对这个改变可见！！！，上面的代码中，如果对get方法也加synchronized也是可见的，还是happens-before的监视器锁规则：对一个监视器的解锁，happens-before 于随后对这个监视器的加锁。只是volatile比synchronized更轻量级，所以本例直接用volatile。但是对于符合非原子操作i++这里还是不行的还是需要synchronized。

synchronized实现可见性对比volatile

　　首先先介绍一下JMM（JAVA内存模型），上图：

java synchronized实现可见性对比volatile

　　java内存模型的工作原理如上图所示，一些被定义的变量都存放在主内存中，当一个线程想要修改一个变量的值时，那么这个变量会从主内存中拷贝到线程的工作内存（CPU缓存）中。之后线程对变量值做了更改，又会重新拷贝回主内存中。大家通过描述也可以看出来这些操作是分步执行的，这样就无法保证可见性和原子性。对于这种情况java也给出了很多解决办法，今天跟大家分享一下我对synchronized以及volatile的理解。

　大家知道synchronized是通过加互斥锁来实现原子性的，JMM关于synchronized的两条规定：

　　(1) 线程解锁前，必须把共享变量的最新之刷新到主内存中
　　(2) 线程加锁前，将清空工作内存中共享变量的值，从而使用共享变量时需要从主内存中重新读取最新的值（注意：加锁与解锁需要时同一把锁）　　

　　我来简单描叙一下线程执行互斥代码的过程：

　　　　1、获得互斥锁
　　　　2、清空工作内存
　　　　3、从主内存拷贝变量的最新副本到工作内存
　　　　4、执行代码
　　　　5、将更改后的共享变量的值刷新到主内存
　　　　6、释放互斥锁
　　synchronized从而实现类原子性，也具备内存可见性。

　　这里多说一下Lock,其实原理跟synchronized类似，但是比synchronized更加灵活，我们会在下一篇博客中详细探讨synchronized的缺陷以及Lock的基本用法。

　　volatile是如何实现内存可见性的呢？

　　深入来说：是通过加入内存屏障和禁止重排序优化来实现的。（重排序指单线程中在保证执行结果不变的前提下java虚拟机为了提升处理速度可能会将指令重排，达到最合理化）

　　对volatile变量执行写操作时，会在写操作后加入一条store屏障指令
　　改变线程工作内存中的volatile变量副本的值
　　将改变后的副本的值从工作内存刷新到主内存

　　对volatile变量执行读操作时，会在读操作前加入一条load屏障指令
　　从主内存中读取volatile变量的最新值到线程的工作内存中
　　从工作内存中读取volatile变量的副本
　　简单来说：volatile变量在每次被线程访问时，都强迫从sy主内存中重读变量的值，而当该变量发生变化时，又会强迫线程将最新的值刷新到主内存。这样在任何时刻，不同的线程总能看到该变量的最新值。从而保证了变量的内存可见性。

　synchronized和volatile的比较

　　volatile不需要加锁，比synchronized更加轻量级，不会阻塞线程
　　从内存可见性讲，volatile读相当于加锁，volatile写相当于解锁
　　synchronized既能保证可见性，又能保证原子性，而volatile只能保证可见性，无法保证原子性