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 重排序规则表：

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

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

• 在每个 volatile 写操作的前面插入一个 StoreStore 屏障。

• 在每个 volatile 写操作的后面插入一个 StoreLoad 屏障。

• 在每个 volatile 读操作的后面插入一个 LoadLoad 屏障。

• 在每个 volatile 读操作的后面插入一个 LoadStore 屏障。

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

　下面是在保守策略下，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);
    }
}

效果：

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

　　添加volatile 关键词观察效果

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

效果：

代码很快正常结束了！

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

---

 synchronized实现可见性对比volatile

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

　　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只能保证可见性，无法保证原子性