转自：https://www.cnblogs.com/yanlong300/p/9056026.html

volatile关键字

volatile关键字是什么

在上一章我们讲到了并发的的三个概念，那么今天在讲解下在java中可以保证可见性和有序性的一个关键字。

volatile关键字 ：当变量的值被该关键字修饰后该值任何读写操作对于其他线程是立即可见的。并且被关键字修饰后的变量被禁止重排序。

volatile原理解析

在定义中我们可以看到volatile关键字有2个特性，可见性和有序性，那么volatile是如何保证这个可见性和有序性的呢？那他为什么不能保证原子性呢？
首先volatile通过加入内存屏障和禁止指令重排序优化来实现的

可见性

写操作

对volatile 变量进行写操作时，会在写操作后添加一个Store Memory Barrier屏障指令将工作内存中的变量写入主内存中。该指令会优先执行在缓冲区所有该变量的相关操作。相当于手动刷新到主内存。

读操作

对volatile变量进行读操作时，会在读操作之前添加一个Load Memory Barrier屏障指令，从主内存读取共享变量。该指令会将失效队列中所有的指令执行，让其他cpu对该变量的改动全部生效，并且刷新回主内存，然后在读取该主内存中的值。相当于手动刷新该变量的最新值。

有序性

volatile关键字 - 图1

  1. StoreStore屏障 该指令之前的写操作不能和该指令之后的写操作重排序.
  2. StoreLoad屏障 该指令之前的写操作和该指令之后的读操作重排序.
  3. LoadLoad屏障 该指令之前的读操作不能和该指令之后的读操作重排序.

  4. LoadStore屏障 该指令之前的读操作不能和该指令之后的写操作重排序。

    写操作

    在volatile写和普通写不能交换位置。也就能保证volatile写的值是最新的值。
    volatile写以及后来的读不能交换位置，也就是后来的读必须在volatile之后执行。

    读操作

    而在volatile读不能与在volatile读之后的读操作和写操作交换位置。也就是说volatile读之后的读写操作都必须在volatile读之后完成。
    注意：Memory Barrier 可以参看CPU缓存一致性协议MESI-硬件内存模型

    volatile适用场景

    例子一

    1. @Slf4j
    2. public class UnsafeExample   {
    3.  private static final int CLIENT_TOTAL = 30000;
    4.  private static final int THREAD_TOTAL = 300;
    5.  private static volatile int count = 0;
    6.  public static void main(String[] args) throws InterruptedException {
    7.      //模拟并发
    8.      ExecutorService executorService = Executors.newCachedThreadPool();
    9.      CountDownLatch countDownLatch = new CountDownLatch(CLIENT_TOTAL);
    10.      Semaphore semaphore = new Semaphore(THREAD_TOTAL);
    11.      for(int i = 0;i<CLIENT_TOTAL;i++){
    12.          executorService.execute(()->{
    13.              try{
    14.                  semaphore.acquire();
    15.                  add();
    16.                  semaphore.release();
    17.              }catch (Exception e){
    18.                  e.printStackTrace();
    19.                  log.error(e.getMessage(),e);
    20.              }
    21.              countDownLatch.countDown();
    22.          });
    23.      }
    24.      countDownLatch.await();
    25.      System.out.println("统计次数："+count);
    26.  }
    27.  private static void add(){
    28.      count++;
    29.  }
    30. }

    通过测试得出volatile并不能保证上述demo的线程安全。也就是说依赖当前值来决定下一个值的场景并不适合volatile。
    通过上述描述可以总结出两点使用场景。

  5. 对该变量的操作不依赖当前值。（读自己 写自己）

  6. 该变量没有包含在具有其他变量的不变式中。 （读别人 写自己）

举个简单的例子

  1. //这种volatile的使用就是错误的 违反了第一条
  2. volatile int x = x+1;
  3. int a = 1;
  4. //这种volatile使用场景是错误的 违反了第二条
  5. volatile int b  = a + 1;

实际上,这些条件表明,可以被写入 volatile 变量的这些有效值独立于任何程序的状态,包括变量的当前状态。
因此特别适合作为状态标记量。

使用场景

1.状态标记

重新举一下在上一章中的例子

  1. @Slf4j
  2. public class SimpleHappenBefore {
  3.     private static int a = 0;
  4.     private static boolean flag = false;
  5.     public static void main(String[] args) throws InterruptedException {
  6.         for (int i = 0; i < 1000; i++) {
  7.             ThreadA threadA = new ThreadA();
  8.             ThreadB threadB = new ThreadB();
  9.             threadA.start();
  10.             threadB.start();
  11.             threadA.join();
  12.             threadB.join();
  13.             a = 0;
  14.             flag = false;
  15.         }
  16.     }
  17.     static class ThreadA extends Thread {
  18.         @Override
  19.         public void run() {
  20.             a = 1;
  21.             flag = true;
  22.         }
  23.     }
  24.     static class ThreadB extends Thread {
  25.         @Override
  26.         public void run() {
  27.             if (flag) {
  28.                 a = a * 1;
  29.             }
  30.             if (a == 0) {
  31.                 System.out.println("ha,a==0");
  32.             }
  33.         }
  34.     }
  35. }

上面的例子中可以看出flag的改变与其他状态 和他自己本身的状态完全没有关系。所以这里使用volatile关键字是合格的。

2.线程安全的单例对象发布

双重检查单例模式方式发布对象
单例模式-懒汉单例

  1. public class LazySingleton {
  2.     private static volatile LazySingleton lazySingleton;
  3.     private LazySingleton() {
  4.     }
  5.     public static LazySingleton getInstance() {
  6.         if (lazySingleton == null) {
  7.             synchronized(LazySingleton.class) {
  8.                 if (lazySingleton == null) {
  9.                     lazySingleton = new LazySingleton();
  10.                 }
  11.             }
  12.         }
  13.         return lazySingleton;
  14.     }
  15. }

3.独立观察（independent observation）

比如论坛常用的统计最后一个注册的用户。

  1. public class UserRegister {
  2.     public volatile String lastRegisterUser;
  3.     public void registerUser(String user, String password) {
  4.             User u = new User();
  5.             u.setUser(user);
  6.             u.setPassword(password);
  7.             userService.registerUser(u);
  8.             lastRegisterUser = user;
  9.     }
  10. }

4.开销较低的读－写锁策略

读操作使用volatile 写操作使用synchronzied

  1. public class Counter {
  2.     private volatile int value;
  3.     public int getValue() { return value; }
  4.     public synchronized int increment() {
  5.         return value++;
  6.     }
  7. }

总结

volatile关键字是一个保证可见性和有序性的关键字。该关键字修饰的变量操作与该变量本身状态以及其他变量状态无关的情况下使用才可以保证其并发安全性。顺便吐槽一下（该变量没有包含在具有其他变量的不变式中）这句话，楼主理解这句话理解了很久，后面突然就顿悟了。对于语言文字的理解能力真的很重要。