java 关键字 volatile初识

﹏ヽ暗。殇╰゛Y 2022-07-26 12:17 177阅读 0赞

# java 关键字 volatile初识 #

## 概述 ##

JMM提供了volatile变量定义、final、synchronized块来保证可见性。
    用volatile修饰的变量，线程在每次使用变量的时候，都会读取变量修改后的值。
    volatile很容易被误用，用来进行原子性操作。

**volatile关键字的两层语义**

**1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。**  
  
**2）禁止进行指令重排序。**

cpu执行指令  
大家都知道，计算机在执行程序时，每条指令都是在CPU中执行的，而执行指令过程中，  
势必涉及到数据的读取和写入。由于程序运行过程中的临时数据是存放在主存（物理内存）  
当中的，这时就存在一个问题，由于CPU执行速度很快，  
而从内存读取数据和向内存写入数据的过程跟CPU执行指令的速度比起来要慢的多，  
因此如果任何时候对数据的操作都要通过和内存的交互来进行，会大大降低指令执行的速度。  
因此在CPU里面就有了高速缓存。  
也就是，当程序在运行过程中，会将运算需要的数据从主存复制一份到CPU的高速缓存当中，  
那么CPU进行计算时就可以直接从它的高速缓存读取数据和向其中写入数据，  
当运算结束之后，再将高速缓存中的数据刷新到主存当中。

因为主存—>高速缓存—>cpu这三个过程，所以导致多线程环境下可能会出现线程安全问题。

--------------------

## volatile的原理和实现机制 ##

下面这段话摘自《深入理解Java虚拟机》：  
“观察加入volatile关键字和没有加入volatile关键字时所生成的汇编代码发现，加入volatile关键字时，会多出一个lock前缀指令”

lock前缀指令实际上相当于一个内存屏障（也成内存栅栏），内存屏障会提供3个功能：

1）它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成；
    
    2）它会强制将对缓存的修改操作立即写入主存；
    
    3）如果是写操作，它会导致其他CPU中对应的缓存行无效。

## 使用场景 ##

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

**使用volatile必须具备以下2个条件：**

1）对变量的写操作不依赖于当前值
    2）该变量没有包含在具有其他变量的不变式中

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

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

**1.状态标识符**

volatile boolean inited = false;
    //线程1:
    context = loadContext();  
    inited = true;            
    
    //线程2:
    while(!inited ){
        sleep()
    }
    doSomethingwithconfig(context);

**2.double check(双重校验)**

class Singleton{
        private volatile static Singleton instance = null;
    
        private Singleton() {
    
        }
    
        public static Singleton getInstance() {
            if(instance==null) {
                synchronized (Singleton.class) {
                    if(instance==null)
                        instance = new Singleton();
                }
            }
            return instance;
        }
    }

**验证volatile不保证变量操作的原子性**

**Count类Code**

public class Count {
    
        //volatile修饰的共享成员变量
        private volatile int num = 0;
        //加1方法
        public void add() {
            try {
                Thread.sleep(1);//故意让其休眠一瞬间
            } catch (InterruptedException e) {
            }
            num++;
        }
    
        public void setNum(int num) {
            this.num = num;
        }
        public int getNum() {
            return num;
        }
    }

**VolatileThread类Code**

public class VolatileThread implements Runnable {
    
        // 共享成员变量
        private Count count;
    
        public VolatileThread(Count count) {
            this.count = count;
        }
    
        @Override
        public void run() {
            int i = 0;
            while (i < 100) {
                i++;
                count.add();
            }
        }
    }

**MainApp Code**

public class MainApp {
    public static void main(String[] args) {
            Count count = new Count();
            VolatileThread voliteThread1 = new VolatileThread(count);
    
            //启动多个线程
            new Thread(voliteThread1).start();
            new Thread(voliteThread1).start();
            new Thread(voliteThread1).start();
            new Thread(voliteThread1).start();
    
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
            }
            System.out.println("总数:"+count.getNum());
        }
    }

**说明:**得出的结果是小于400的，每次都不唯一数值。

--------------------

## 参考 ##

1.  [http://www.tuicool.com/articles/veuyeyV][http_www.tuicool.com_articles_veuyeyV]
2.  [http://www.ibm.com/developerworks/cn/java/j-jtp06197.html][http_www.ibm.com_developerworks_cn_java_j-jtp06197.html]

[http_www.tuicool.com_articles_veuyeyV]: http://www.tuicool.com/articles/veuyeyV
[http_www.ibm.com_developerworks_cn_java_j-jtp06197.html]: http://www.ibm.com/developerworks/cn/java/j-jtp06197.html