（转）java之用volatile和不用volatile的区别

在当前的Java内存模型下，线程可以把变量保存在本地内存（比如机器的寄存器）中，而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值，而另外一个线程还继续使用它在寄存器中的变量值的拷贝，造成数据的不一致。 

要解决这个问题，只需要像在本程序中的这样，把该变量声明为volatile（不稳定的）即可，这就指示JVM，这个变量是不稳定的，每次使用它都到主存中进行读取。一般说来，多任务环境下各任务间共享的标志都应该加volatile修饰。 

Volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。 

 

用volatile和不用volatile的区别，运行一下，就知道了。

不用volatile：

 

[java]  view plain  copy

 

 

1. package com.keyword;  
2.   
3. public class TestWithoutVolatile {  
4.     private static boolean bChanged;  
5.   
6.     public static void main(String[] args) throws InterruptedException {  
7.         new Thread() {  
8.   
9.             @Override  
10.             public void run() {  
11.                 for (;;) {  
12.                     if (bChanged == !bChanged) {  
13.                         System.out.println("!=");  
14.                         System.exit(0);  
15.                     }  
16.                 }  
17.             }  
18.         }.start();  
19.         Thread.sleep(1);  
20.         new Thread() {  
21.   
22.             @Override  
23.             public void run() {  
24.                 for (;;) {  
25.                     bChanged = !bChanged;  
26.                 }  
27.             }  
28.         }.start();  
29.     }  
30.   
31. }  

运行后，程序进入死循环了，一直在运行。

 

 

用volatile：

 

[java]  view plain  copy

 

 

1. package com.keyword;  
2.   
3. public class TestWithVolatile {  
4.     private static volatile boolean bChanged;  
5.   
6.     public static void main(String[] args) throws InterruptedException {  
7.         new Thread() {  
8.   
9.             @Override  
10.             public void run() {  
11.                 for (;;) {  
12.                     if (bChanged == !bChanged) {  
13.                         System.out.println("!=");  
14.                         System.exit(0);  
15.                     }  
16.                 }  
17.             }  
18.         }.start();  
19.         Thread.sleep(1);  
20.         new Thread() {  
21.   
22.             @Override  
23.             public void run() {  
24.                 for (;;) {  
25.                     bChanged = !bChanged;  
26.                 }  
27.             }  
28.         }.start();  
29.     }  
30.   
31. }  

程序输出!=，然后马上退出。

 

但是，很多情况下，用不用volatile，感觉不出什么区别，什么时候要用volatile呢？看看JDK里使用volatile的类。

比如java.util.regex.Pattern里的变量：

 

[java]  view plain  copy

 

 

1. private transient volatile boolean compiled = false;  

还有，java.lang.System的变量：

 

 

[java]  view plain  copy

 

 

1. private static volatile Console cons = null;  

一般就是初始化的时候，需要用到volatile。

 

java.util.Scanner里的变量，如：

 

[java]  view plain  copy

 

 

1. private static volatile Pattern boolPattern;  
2. private static volatile Pattern separatorPattern;  
3. private static volatile Pattern linePattern;  

初始化boolPattern的代码：

 

 

[java]  view plain  copy

 

 

1. private static Pattern boolPattern() {  
2.         Pattern bp = boolPattern;  
3.         if (bp == null)  
4.             boolPattern = bp = Pattern.compile(BOOLEAN_PATTERN,  
5.                                           Pattern.CASE_INSENSITIVE);  
6.         return bp;  
7. }  

 

 

上面的情况，可以使用synchronized来对boolPattern加锁，但是synchronized开销比volatile大，volatile能够胜任上面的工作。

 

volatile不保证原子操作，所以，很容易读到脏数据。

 

使用建议：在两个或者更多的线程访问的成员变量上使用volatile。当要访问的变量已在synchronized代码块中，或者为常量时，不必使用。 

 

参考：

http://sudalyl.blog.163.com/blog/static/1018092742010925901769/

 

REFS:http://blog.csdn.net/feier7501/article/details/20001083