备战Java面试【面试高频】 -- 详解volatile关键字

Free的午后
115 阅读5分钟

​

 ​​


因为热爱所以坚持，因为热爱所以等待。熬过漫长无戏可演的日子，终于换来了人生的春天，共勉！！！

1.volatile初步理解

java虚拟机提供的轻量级的同步机制，主要有三个特性：

  • 保证可见性
  • 不保证原子性
  • 禁止指令重排

讲到可见性、原子性这些，我们就不得不提下面这个JMM

2.JMM（Java Memory Model）模型

JMM是一种抽象的概念，描述的是一组规则或规范，通过这种规范定义程序各个变量（包括实例字段、静态字段和构成数组的对象的元素）的访问方式。

  • JMM关于同步的规定：
  1. 线程解锁前，必须把共享变量的值刷新回主内存
  2. 线程加锁前，必须读取主内存的最新值到自己的工作内存
  3. 加锁解锁是同一把锁
  • 8种操作:

Read（读取）：作用于主内存变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用；

load（载入）：作用于工作内存的变量，它把read操作从主存中变量放入工作内存中；

Use（使用）：作用于工作内存中的变量，它把工作内存中的变量传输给执行引擎，每当虚拟机遇到一个需要使用到变量的值，就会使用到这个指令；

assign（赋值）：作用于工作内存中的变量，它把一个从执行引擎中接受到的值放入工作内存的变量副本中；

store（存储）：作用于主内存中的变量，它把一个从工作内存中一个变量的值传送到主内存中，以便后续的write使用；

write（写入）：作用于主内存中的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中；

lock（锁定）：作用于主内存的变量，把一个变量标识为线程独占状态；

unlock（解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定

由于JVMi运行程序的实体是线程，而每个线程创建时JVM都会为其创建一个工作内存(有些地方称为栈空间)，工作内存是每个线程的私有数据区域，而Java内存模型中规定所有变量都存储在主内存，主内存是共享内存区域，所有线程都可以访问，但线程对变量的操作(读取赋值等)必须在工作内存中进行，首先要将变量从主内存拷贝的自己的工作内存空间，然后对变量进行操作，操作完成
后再将变量写回主内存，不能直接操作主内存中的变量，各个线程中的工作内存中存储着主内存中的变量副本拷贝，因此不同的线程间无法访问对方的工作内存，线程间的通信(传值)必须通过主内存来完成，其简要访问过程如下图:
​

2.保证可见性

如何实现可见性

volatile变量修饰的共享变量在进行写操作的时候回多出一行汇编，JVM向CPU发送lock前缀指令

0x01a3de1d:movb 0×0，0×1104800（0×0，0×1104800（%esi）;0x01a3de24**:lock** addl 0×0,(%esp);

    ​

Lock前缀的指令在多核处理器下会引发两件事情。

  1. 将当前处理器缓存行的数据写回到系统内存。
  2. 这个写回内存的操作会使其他cpu里缓存了该内存地址的数据无效。

多处理器总线嗅探：

​ 为了提高处理速度，处理器不直接和内存进行通信，而是先将系统内存的数据读到内部缓存后再进行操作，但操作不知道何时会写到内存。如果对声明了volatile的变量进行写操作，JVM就会向处理器发送一条lock前缀的指令，将这个变量所在缓存行的数据写回到系统内存。但是在多处理器下，为了保证各个处理器的缓存是一致的，就会实现缓存缓存一致性协议(CPU级别） ，每个处理器通过嗅探在总线上传播的数据来检查自己的缓存值是不是过期了，如果处理器发现自己缓存行对应的内存地址被修改，就会将当前处理器的缓存行设置无效状态，当处理器对这个数据进行修改操作的时候，会重新从系统内存中把数据读到处理器缓存中。

  • MESI（缓存一致协议）​ 原理：各个CPU会对总线进行嗅探，如果发现有人修改了某个缓存的数据，那么CPU就会

将自己本地的缓存过期掉，再次读取那个变量的时候，就会从主内存重新加载最新
的数据

​

3.保证有序性

内存屏障 

​

4.不能保证原子性

通过一个实例来展示volatile并不能保证原子性

public class Test {
    public volatile int inc = 0;
     
    public void increase() {
        inc++;
    }
     
    public static void main(String[] args) {
        final Test test = new Test();
        for(int i=0;i<10;i++){
            new Thread(){
                public void run() {
                    for(int j=0;j<1000;j++)
                        test.increase();
                };
            }.start();
        }
         
        while(Thread.activeCount()>1)  //保证前面的线程都执行完
            Thread.yield();
        System.out.println(test.inc);
    }
}

运行它会发现每次运行结果都不一致，都是一个小于10000的数字

​​​​

 上面是对变量inc进行自增操作，由于volatile保证了可见性，那么在每个线程中对inc自增完之后，在其他线程中都能看到修改后的值啊，所以有10个线程分别进行了1000次操作，那么最终inc的值应该是1000*10=10000。

这里面就有一个误区了，volatile关键字能保证可见性没有错，但是上面的程序错在没能保证原子性。可见性只能保证每次读取的是最新的值，但是volatile没办法保证对变量的操作的原子性

i++ 不是一个原子性操作，它分为三个步骤，读取i的值，对i加1，然后写回去，这三步才完成i++操作，但是在多线程下，由于volatile没法保证原子性，所以当同时有两个线程时，假设i当前为1，两个线程读到i都为1，并且都执行加1操作，然后两个写回去都是2，执行了两次操作，但结果是只有一次是有效的，所以造成计算结果变小了。

解决这种情况可以使用以下办法：

  • 采用synchronized
public class Test2 {
    public  int inc = 0;
    
    public synchronized void increase() {
        inc++;
    }
    
    public static void main(String[] args) {
        final Test test2 = new Test();
        for(int i=0;i<10;i++){
            new Thread(){
                public void run() {
                    for(int j=0;j<1000;j++)
                        test2.increase();
                };
            }.start();
        }
        
        while(Thread.activeCount()>1)  //保证前面的线程都执行完
            Thread.yield();
        System.out.println(test2.inc);
    }
}

结果：   ​

  • 采用lock
public class Test3 {
    public  int inc = 0;
    Lock lock = new ReentrantLock();
    
    public  void increase() {
        lock.lock();
        try {
            inc++;
        } finally{
            lock.unlock();
        }
    }
    
    public static void main(String[] args) {
        final Test test3 = new Test();
        for(int i=0;i<10;i++){
            new Thread(){
                public void run() {
                    for(int j=0;j<1000;j++)
                        test3.increase();
                };
            }.start();
        }
        
        while(Thread.activeCount()>1)  //保证前面的线程都执行完
            Thread.yield();
        System.out.println(test3.inc);
    }
}

结果：   ​

  • 采用原子操作类AtomicInteger
public class Test4 {
    public  AtomicInteger inc = new AtomicInteger();
     
    public  void increase() {
        inc.getAndIncrement();
    }
    
    public static void main(String[] args) {
        final Test test4 = new Test();
        for(int i=0;i<10;i++){
            new Thread(){
                public void run() {
                    for(int j=0;j<1000;j++)
                        test4.increase();
                };
            }.start();
        }
        
        while(Thread.activeCount()>1)  //保证前面的线程都执行完
            Thread.yield();
        System.out.println(test4.inc);
    }
}

　在java 1.5的java.util.concurrent.atomic包下提供了一些原子操作类，即对基本数据类型的 自增（加1操作），自减（减1操作）、以及加法操作（加一个数），减法操作（减一个数）进行了封装，保证这些操作是原子性操作。atomic是利用CAS来实现原子性操作的（Compare And Swap），CAS 比较当前工作内存中的值 和 主内存中的值，如果这个值是期望的，那么则执行操作！如果不是就一直循环，使用的是自旋锁。

5.使用volatile关键字的场景

　　synchronized关键字是防止多个线程同时执行一段代码，那么就会很影响程序执行效率，而volatile关键字在某些情况下性能要优于synchronized，但是要注意volatile关键字是无法替代synchronized关键字的，因为volatile关键字无法保证操作的原子性。通常来说，使用volatile必须具备以下2个条件：

　　1）对变量的写操作不依赖于当前值

　　2）该变量没有包含在具有其他变量的不变式中

　　实际上，这些条件表明，可以被写入 volatile 变量的这些有效值独立于任何程序的状态，包括变量的当前状态。

　　事实上，我的理解就是上面的2个条件需要保证操作是原子性操作，才能保证使用volatile关键字的程序在并发时能够正确执行。

实际应用：

  • DCL懒汉式
  • 作为状态位标记

​​

参考：

blog.csdn.net/jjavaboy/ar…

blog.csdn.net/weixin_4449…

马士兵讲volatile五层实现

​

avatar
文章
阅读
粉丝