[转]Java多线程：慎重使用volatile关键字

Java 语言中的 volatile 变量可以被看作是一种 “程度较轻的 synchronized”；与 synchronized 块相比，volatile 变量所需的编码较少，并且运行时开销也较少，但是它所能实现的功能也仅是 synchronized 的一部分。

validate关键字实现加锁的原理：

在当前的Java内存模型下，线程可以把变量保存在本地内存（比如机器的寄存器）中，而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值，而另外一个线程还继续使用它在寄存器中的变量值的拷贝，造成数据的不一致。Volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。要解决这个问题，只需要像在本程序中的这样，把该变量声明为volatile（不稳定的）即可，这就指示JVM，这个变量是不稳定的，每次使用它都到主存中进行读取。一般说来，多任务环境下各任务间共享的标志都应该加volatile修饰。

volatile关键字相信了解Java多线程的读者都很清楚它的作用。volatile关键字用于声明简单类型变量，如int、float、boolean等数据类型。如果这些简单数据类型声明为volatile，对它们的操作就会变成原子级别的。但这有一定的限制。例如，下面的例子中的n就不是原子级别的：

1. package mythread;  
2.  
3. public class JoinThread extends Thread  
4. {  
5.     public static volatile int n = 0;  
6.     public void run()  
7.     {  
8.         for (int i = 0; i < 10; i++)  
9.             try 
10.         {  
11.                 n = n + 1;  
12.                 sleep(3); // 为了使运行结果更随机，延迟3毫秒  
13.  
14.             }  
15.             catch (Exception e)  
16.             {  
17.             }  
18.     }  
19.  
20.     public static void main(String[] args) throws Exception  
21.     {  
22.  
23.         Thread threads[] = new Thread[100];  
24.         for (int i = 0; i < threads.length; i++)  
25.             // 建立100个线程  
26.             threads[i] = new JoinThread();  
27.         for (int i = 0; i < threads.length; i++)  
28.             // 运行刚才建立的100个线程  
29.             threads[i].start();  
30.         for (int i = 0; i < threads.length; i++)  
31.             // 100个线程都执行完后继续  
32.             threads[i].join();  
33.         System.out.println("n=" + JoinThread.n);  
34.     }  
35. }  
36.        

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

n = n + 1;
n++;

如果要想使这种情况变成原子操作，需要使用synchronized关键字，如上的代码可以改成如下的形式：

1. package mythread;  
2.  
3. public class JoinThread extends Thread  
4. {  
5.     public static int n = 0;  
6.  
7.     public static synchronized void inc()  
8.     {  
9.         n++;  
10.     }  
11.     public void run()  
12.     {  
13.         for (int i = 0; i < 10; i++)  
14.             try 
15.             {  
16.                 inc(); // n = n + 1 改成了 inc();  
17.                 sleep(3); // 为了使运行结果更随机，延迟3毫秒  
18.  
19.             }  
20.             catch (Exception e)  
21.             {  
22.             }  
23.     }  
24.  
25.     public static void main(String[] args) throws Exception  
26.     {  
27.  
28.         Thread threads[] = new Thread[100];  
29.         for (int i = 0; i < threads.length; i++)  
30.             // 建立100个线程  
31.             threads[i] = new JoinThread();  
32.         for (int i = 0; i < threads.length; i++)  
33.             // 运行刚才建立的100个线程  
34.             threads[i].start();  
35.         for (int i = 0; i < threads.length; i++)  
36.             // 100个线程都执行完后继续  
37.             threads[i].join();  
38.         System.out.println("n=" + JoinThread.n);  
39.     }  
40. }  

上面的代码将n=n+1改成了inc()，其中inc方法使用了synchronized关键字进行方法同步。因此，在使用volatile关键字时要慎重，并不是只要简单类型变量使用volatile修饰，对这个变量的所有操作都是原来操作，当变量的值由自身的上一个决定时，如n=n+1、n++等，volatile关键字将失效，只有当变量的值和自身上一个值无关时对该变量的操作才是原子级别的，如n = m + 1，这个就是原级别的。

 

使用到的地方：

1. 当要访问的变量已在synchronized代码块中，或者为常量时，不必使用。

使用不合适的地方：

1. 效率要求高的项目，由于使用屏蔽掉了VM中必要的代码优化，所以在效率上比较低，因此一定在必要时才使用此关键字。
2. 当要访问的变量已在synchronized代码块中，或者为常量时，不必使用。

所以在使用volatile关键时一定要谨慎，如果自己没有把握，可以使用synchronized来代替volatile。