Volatile与Synchronized

先从Java内存模型说起（图片来源于网络，侵删），看图：

1.jpg

在多CPU的系统中，每个CPU都有多级缓存，一般分为L1，L2，L3缓存，因为这些缓存的存在，提高了数据的访问性能，也减轻了数据总线上数据传输的压力。却也带来了新的问题，比如两个CPU同时操作一个内存地址。
在CPU层面，内存模型定义了一个充分必要条件，保证其他CPU的写入动作对该CPU是可见的，而且该CPU的写入动作对其他的CPU也是可见的，这种可见性如何实现，有强内存模型也有弱内存模型，此处暂且按下不表。

这里我们先看看，在java内存模型中，volatile与synchronized对实现线程安全都做了些什么。

2.jpg

synchronized遇到线程的不安全问题，是怎样操作的呢？
1）在程序进入synchronized代码块时，会将synchronized代码块中使用到的变量从工作内存中删除，再从主内存中取值。
2）在执行完synchronized代码块时，会将修改过的变量刷新到主内存中。

volatile在遇到线程不安全的问题时，又做了些什么？当一个变量被声明为volatile变量时，
1）线程在读取共享变量时，会先清空工作内存中的值，再从主内存中读取。
2）线程在写入共享变量时，不会写入到工作内存中，而是直接写入到主内存中。

看了这段描述，你是不是跟我一样，以为这两个关键字在线程安全方面做的事情，都是相同的。接着往下看，上代码：

synchronized代码实例

@Slf4j
public class ThreadSafeSynchronized {
    private static final int TOTAL = 10000;

    private int count;

    private synchronized void add10Count(){
        int start = 0;

        while(start++ < TOTAL){
            this.count ++;
        }
    }

    public static void main(String[] args) {

        ThreadSafeSynchronized threadSafeSynchronized = new ThreadSafeSynchronized();

        Thread thread1 = new Thread(() -> threadSafeSynchronized.add10Count());
        Thread thread2 = new Thread(() -> threadSafeSynchronized.add10Count());

        thread1.start();
        thread2.start();

        try{
            thread1.join();
            thread2.join();
        }catch (InterruptedException e) {
            log.error(e.getMessage());
        }

        log.info("ThreadSafeSynchronized, count值: {}",threadSafeSynchronized.count);
    }
}

运行结果：

 INFO - ThreadSafeSynchronized, count值: 20000

volatile代码实例

@Slf4j
public class ThreadSafeVolatile {
    private static final int TOTAL = 10000;

    private volatile int count;

    private void add10Count(){
        int start = 0;

        while(start++ < TOTAL){
            this.count ++;
        }
    }

    public static void main(String[] args) {

        ThreadSafeVolatile threadSafeVolatile = new ThreadSafeVolatile();

        Thread thread1 = new Thread(() -> threadSafeVolatile.add10Count());
        Thread thread2 = new Thread(() -> threadSafeVolatile.add10Count());

        thread1.start();
        thread2.start();

        try{
            thread1.join();
            thread2.join();
        }catch (InterruptedException e) {
            log.error(e.getMessage());
        }

        log.info("ThreadSafeVolatile, count值: {}",threadSafeVolatile.count);
    }
}

运行结果：

INFO - ThreadSafeVolatile, count值: 13804

好神奇是不是？想知道为什么吗？来，继续看。

count++  程序代码是一行，但是翻译成 CPU 指令却是三行

synchronized是具备原子性的，在线程独占锁期间，这三条CPU指令是一次性执行完的。
volatile是不具备原子性的，三条CPU指令执行期间，是会有其他线程的CPU指令插足的。划重点：volatile 能保证内存可见性，但是不能保证原子性。

那么，在什么情况下，能使用volatile呢？死记硬背下来：

如果写入变量值不依赖变量当前值，那么就可以用 volatile

另外，volatile 除了还能解决可见性问题，还能解决编译优化重排序问题，这个后面再来讲。