java volatile总结

当一个变量被定义成volatile 之后，它将具备以下几种特性：

第一：第一是保证此变量对所有线程的可见性，这里的"可见性"是指当一条线程修改了这个变量，新值对于其他线程来说是可以立即得知的。而普通变量不能做到这一点，变量值在线程间传递均需要通过主内存来完成。

在 java 垃圾回收整理一文中，描述了jvm运行时刻内存的分配。其中有一个内存区域是jvm虚拟机栈，每一个线程运行时都有一个线程栈，

线程栈保存了线程运行时候变量值信息。当线程访问某一个对象时候值的时候，首先通过对象的引用找到对应在堆内存的变量的值，然后把堆内存

变量的具体值load到线程本地内存中，建立一个变量副本，之后线程就不再和对象在堆内存变量值有任何关系，而是直接修改副本变量的值，

在修改完之后的某一个时刻（线程退出之前），自动把线程变量副本的值回写到对象在堆中变量。这样在堆中的对象的值就产生变化了。下面一幅图

描述这写交互

 

 

 

read and load 从主存复制变量到当前工作内存
use and assign  执行代码，改变共享变量值 
store and write 用工作内存数据刷新主存相关内容

其中use and assign 可以多次出现

但是这一些操作并不是原子性，也就是 在read load之后，如果主内存count变量发生修改之后，线程工作内存中的值由于已经加载，不会产生对应的变化，所以计算出来的结果会和预期不一样

对于volatile修饰的变量，jvm虚拟机只是保证从主内存加载到线程工作内存的值是最新的

例如假如线程1，线程2 在进行read,load 操作中，发现主内存中count的值都是5，那么都会加载这个最新的值

在线程1堆count进行修改之后，会write到主内存中，主内存中的count变量就会变为6

线程2由于已经进行read,load操作，在进行运算之后，也会更新主内存count的变量值为6

导致两个线程及时用volatile关键字修改之后，还是会存在并发的情况。

Java内存模型中对volatile 变量定义的特殊规则：

• volatile变量的操作必须按read->load->use顺序，即每次在工作内存中使用变量前必须先从主内存中刷新最新的值，以保证能看到其他线程对变量的最新修改。
• volatile变量的操作必须按assign->store->write顺序，即每次在工作内存为变量赋值之后必须将变量的值同步回主内存，以保证让其他线程能看到变量的最新修改。
• 若线程对volatile变量A的assign或者use操作先于对volatile变量B的assign或者use操作，则线程对volatile变量A的read/load或者store/write操作也必定先于对volatile变量B的read/load或者store/write操作

第二： volatile关键字用于声明简单类型变量，如int、float、 boolean等数据类型。如果这些简单数据类型声明为volatile，对它们的操作就会变成原子级别的。但这有一定的限制.即运算结果并不依赖变量的当前值，或者能够确保只有单一的线程修改变量的值。查看以下一段代码，下面的n就不是原子级别的。

1. public   class  JoinThread  extends  Thread  
2. {  
3.      public   static volatile int  n  =   0 ;  
4.     public   void  run()  
5.     {  
6.          for  ( int  i  =   0 ; i  <   10 ; i ++ )  
7.              try   
8.         {  
9.                 n  =  n  +   1 ;  
10.                 sleep( 3 );  //  为了使运行结果更随机，延迟3毫秒   
11.   
12.             }  
13.              catch  (Exception e)  
14.             {  
15.             }  
16.     }  

1.      public   static   void  main(String[] args)  throws  Exception  
2.     {  
3.   
4.         Thread threads[]  =   new  Thread[ 100 ];  
5.          for  ( int  i  =   0 ; i  <  threads.length; i ++ )  
6.              //  建立100个线程   
7.             threads[i]  =   new  JoinThread();  
8.          for  ( int  i  =   0 ; i  <  threads.length; i ++ )  
9.              //  运行刚才建立的100个线程   
10.             threads[i].start();  
11.          for  ( int  i  =   0 ; i  <  threads.length; i ++ )  
12.              //  100个线程都执行完后继续   
13.             threads[i].join();  
14.         System.out.println( " n= "   +  JoinThread.n);  
15.     }  
16. }   

如果对n的操作是原子级别的，最后输出的结果应该为n=1000，而在执行上面积代码时，很多时侯输出的n都小于1000，这说明n=n+1不是原子级别的操作。原因是声明为volatile的简单变量如果当前值由该变量以前的值相关，那么volatile关键字不起作用，也就是说如下的表达式都不是原子操作： 

n  =  n  +   1 ; 
n ++ ; 

因此即便对于一些如Boolean,int类型的变量，如果变量的值由自身的上一个决定时，如n=n+1、n++ 等，volatile关键字将失效，只有当变量的值和自身上一个值无关时对该变量的操作才是原子级别的，如n = m + 1，这个就是原级别的。

第三：可以禁止JVM对指令进行重排序。

很多介绍JVM并发的书或文章都会谈到JVM为了优化性能，采用了指令重排序，但是对于什么是指令重排序，为什么重排序会优化性能却很少有提及，其实道理很简单，假设有这么两个共享变量a和b:

private int a;

private int b;

在线程A中有两条语句对这两个共享变量进行赋值操作:

a = 1;

b = 2;

假设当线程A对a进行复制操作的时候发现这个变量在主内存已经被其它的线程加了访问锁，那么此时线程A怎么办？ 等待释放锁？不，等待太浪费时间了，它会去尝试进行b的赋值操作，b这时候没被人占用 ，因此就会先为b赋值，再去为a赋值，那么执行的顺序就变成了:

b = 2;

a = 1;

对于在同一个线程内，这样的改变是不会对逻辑产生影响的，但是在多线程的情况下指令重排序会带来问题，看下面这个情景:

在线程A中:

context = loadContext();

inited = true;

在线程B中:

while(!inited ){

      sleep 

}

doSomethingwithconfig(context);

假设A中发生了重排序:

inited = true;

context = loadContext();

那么B中很可能就会拿到一个尚未初始化或尚未初始化完成的context,从而引发程序错误。

想到有一条古老的原则很适合用在这个地方，那就是先要保证程序的正确然后再去优化性能。此处由于重排序产生的错误显然要比重排序带来的性能优化要重要的多。要解决重排序问题还是通过volatile关键字，volatile关键字能确保变量在线程中的操作不会被重排序而是按照代码中规定的顺序进行访问。