Java 多线程：volatile 多线程同步关键字

（转载）http://blog.csdn.net/allen215902/article/details/50427528

volatile 也是 多线程的解决方案之一。volatile 能够保证 可见性，但是不能保证原子性。它只能作用于变量，不能作用于方法。当一个变量被声明为 volatile 的时候，任何 对该变量的读写都会绕过 高速缓存，直接读取主内存的变量的值。

如何理解直接读写主内存的值：回到 多线程产生的原因 ，在 i＋＋ 操作的时候，当 进行 执行引擎 对 变量  进行 ＋ 1 之后，原来 是应该写入到 本地内存中，再由本地内存写入到主内存中，但是 由于 变量使用了 volatile 的修饰，所以 该值不会经过本地内存，而是直接写入到 主内存中去。 读取也是同样的道理。

使用volatile 有两点需要注意的地方：

• 运算结果并不依赖于当前值，或者能确保只有单一的线程能够修改变量的值。
• 变量不需要和其他的状态变量共同参与不变约束

对于第一点的理解： [java] view plain copy

1. public class main {    
2.     public static int i = 0;    
3.     public static void main(String args[]){    
4.             
5.         new Thread(new Runnable(){    
6.             public void run(){    
7.                 for(int j = 0; j < 10000; j++)    
8.                     i++;    
9.                 System.out.println("Thread1 end...");    
10.             }    
11.         }).start();;    
12.             
13.         new Thread(new Runnable(){    
14.             public void run(){    
15.                 for(int j = 0; j < 10000; j++)    
16.                     i++;    
17.                 System.out.println("Thread2 end...");    
18.             }    
19.         }).start();    
20.             
21.         i++;    
22.             
23.         try {    
24.             Thread.sleep(500);    
25.         } catch (InterruptedException e) {    
26.             // TODO Auto-generated catch block    
27.             e.printStackTrace();    
28.         }    
29.          ，  
30.         System.out.println("i = " + i);    
31.     }    
32. }    

 以上程序不一定全会打印出 20000.分析如下：

• 正常情况下：A 线程取得 主内存的值 i，进行修改，再写回到 主内存，B线程 取得主内存的值 i，进行修改，再写回主内存。这种情况下是正常打印出 20000。
• 非正常情况下：A线程取得 主内存的值 i， B 内存取得主内存的值 i，A线程修改后写回主内存，B线程修改后写回主内存。这种情况下，结果就少了 1.

这也是为什么说 volatile 只是保证可见性，不保证原子性。所以说，只能有单一的线程修改共享变量，才可以使用 volatile。

对于第二点的理解：
[java] view plain copy

1. private Date start;      
2. private Date end;      
3.       
4. public void setInterval(Date newStart, Date newEnd) {      
5.     // 检查start<end是否成立, 在给start赋值之前不变式是有效的      
6.     start = newStart;      
7.       
8.     // 但是如果另外的线程在给start赋值之后给end赋值之前时检查start<end, 该不变式是无效的      
9.       
10.     end = newEnd;      
11.     // 给end赋值之后start<end不变式重新变为有效      
12. }    

最后，关于什么时候使用 volatile，一般是用来当做标记来使用。比如说，当shutdown() 方法被调用的时候，所有的 doWork() 方法都会停下来。