volatile关键字简介及其原理

volatile关键字简介及其原理

要讲Volatile关键字，我们需要从内存模型开说起

在 JDK1.2 之前，Java的内存模型实现总是从主存（即共享内存）读取变量，是不需要进行特别的注意的。而在当前的 Java 内存模型下，线程可以把变量保存本地内存（比如机器的寄存器）中，而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值，而另外一个线程还继续使用它在寄存器中的变量值的拷贝，造成数据的不一致

要解决这个问题，就需要把变量声明为volatile，这就指示 JVM，这个变量是不稳定的，每次使用它都到主存中进行读取

说白了， volatile 关键字的主要作用就是保证变量的可见性然后还有一个作用是防止指令重排序

synchronized 关键字和 volatile 关键字的区别

synchronized关键字和volatile关键字比较

• volatile关键字是线程同步的轻量级实现，所以volatile性能肯定比synchronized关键字要好。但是volatile关键字只能用于变量而synchronized关键字可以修饰方法以及代码块。synchronized关键字在JavaSE1.6之后进行了主要包括为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁以及其它各种优化之后执行效率有了显著提升，实际开发中使用 synchronized 关键字的场景还是更多一些。
• 多线程访问volatile关键字不会发生阻塞，而synchronized关键字可能会发生阻塞
• volatile关键字能保证数据的可见性，但不能保证数据的原子性。synchronized关键字两者都能保证。
• volatile关键字主要用于解决变量在多个线程之间的可见性，而 synchronized关键字解决的是多个线程之间访问资源的同步性。

贴一段代码给大家感受一下

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * volatile并不能保证多个线程共同修改running变量时所带来的不一致问题，也就是说volatile不能替代synchronized
 */
class T {
    volatile int count=0;
    void m(){
        for (int i = 0; i < 1000000; i++) {
            count++;
        }
    }

    public static void main(String[] args) {
        T t=new T();

        List<Thread> threads=new ArrayList<>(); /*创建线程list*/

        for (int i = 0; i < 10; i++) {
            threads.add(new Thread(t::m,"thread-"+i));
        }

        threads.forEach((o)->o.start());

        threads.forEach((o)->{
            try {
                o.join(); /*join  ->  Waits for this thread to die*/
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        System.out.println(t.count);
    }
}

执行结果为3419156，但1000000才是正确结果 -->使用synchronized可以解决

Valatile原理-内存屏障

内存屏障，洋文称Memory Barrier（Memory Fence）

Valatile基于内存屏障保证了共享变量的可见性与有序性

之前提到valatile可以避免指令重排导致的运行结果正确性问题，事实上，valatile并不是通过禁止指令重排那么简单，而是通过内存屏障，保证的有序性

• 可见性

  • 写屏障（sfence）保证在该屏障之前的，对共享变量的改动，都同步到主存当中
  • 读屏障（lfence）保证在该屏障之后，对共享变量的读取，加载的是主存中最新数据

• 有序性

  • 写屏障会确保指令重排序时，不会将写屏障之前的代码排在写屏障之后
  • 读屏障会确保指令重排序时，不会将读屏障之后的代码排在读屏障之前

体现在valatile中就两点

• 对 volatile 变量的写指令后会加入写屏障
• 对 volatile 变量的读指令前会加入读屏障

Valatile如何保证可见性

• 写屏障（sfence）保证在该屏障之前的，对共享变量的改动，都同步到主存当中

• public void actor2(I_Result r) {
   num = 2;
   ready = true; // ready 是 volatile 赋值带写屏障
   // 写屏障
  }
  

• 读屏障（lfence）保证在该屏障之后，对共享变量的读取，加载的是主存中最新数据

• public void actor1(I_Result r) {
   // 读屏障
   // ready 是 volatile 读取值带读屏障
   if(ready) {
   r.r1 = num + num;
   } else {
   r.r1 = 1;
   }
  }
  

  

Valatile如何保证有序性

• 写屏障会确保指令重排序时，不会将写屏障之前的代码排在写屏障之后

  public void actor2(I_Result r) {
   num = 2;
   ready = true; // ready 是 volatile 赋值带写屏障
   // 写屏障
  }
  

• 读屏障会确保指令重排序时，不会将读屏障之后的代码排在读屏障之前

  public void actor1(I_Result r) {
   // 读屏障
   // ready 是 volatile 读取值带读屏障
   if(ready) {
   r.r1 = num + num;
   } else {
   r.r1 = 1;
   }
  }
  

缺陷

无法解决指令交错问题：

多个线程各自代码有序并不能保证多个线程总的代码有序

读写的屏障底层事实是通过JMM内存模型定义的lock指令来实现