Java中关键字volatile的作用

用在多线程，同步变量。 线程为了提高效率，将某成员变量(如A)拷贝了一份（如B），线程中对A的访问其实访问的是B。只在某些动作时才进行A和B的同步。因此存在A和B不一致的情况。volatile就是用来避免这种情况的。volatile告诉jvm， 它所修饰的变量不保留拷贝，直接访问主内存中的（也就是上面说的A)

在Java内存模型中，有main memory，每个线程也有自己的memory (例如寄存器)。为了性能，一个线程会在自己的memory中保持要访问的变量的副本。这样就会出现同一个变量在某个瞬间，在一个线程的memory中的值可能与另外一个线程memory中的值，或者main memory中的值不一致的情况。

一个变量声明为volatile，就意味着这个变量是随时会被其他线程修改的，因此不能将它cache在线程memory中。以下例子展现了volatile的作用：

public class StoppableTask extends Thread {

private volatile boolean pleaseStop;

public void run() {

while (!pleaseStop) {

// 需要执行的其他操作...

}

}

public void tellMeToStop() {

pleaseStop = true;

}

}

假如pleaseStop没有被声明为volatile，线程执行run的时候检查的是自己的副本，就不能及时得知其他线程已经调用tellMeToStop()修改了pleaseStop的值。

Volatile一般情况下不能代替sychronized，因为volatile不能保证操作的原子性，即使只是i++，实际上也是由多个原子操作组成：read i; inc; write i，假如多个线程同时执行i++，volatile只能保证他们操作的i是同一块内存，但依然可能出现写入脏数据的情况。如果配合Java 5增加的atomic wrapper classes，对它们的increase之类的操作就不需要sychronized。

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

package  mythread;

public   class  JoinThread  extends  Thread
{
public   static volatile int  n  =   0 ;
public   void  run()
{
for  ( int  i  =   0 ; i  <   10 ; i ++ )
try
{
n  =  n  +   1 ;
sleep( 3 );  //  为了使运行结果更随机，延迟3毫秒

}
catch  (Exception e)
{
}
}

public   static   void  main(String[] args)  throws  Exception
{

Thread threads[]  =   new  Thread[ 100 ];
for  ( int  i  =   0 ; i  <  threads.length; i ++ )
//  建立100个线程
threads[i]  =   new  JoinThread();
for  ( int  i  =   0 ; i  <  threads.length; i ++ )
//  运行刚才建立的100个线程
threads[i].start();
for  ( int  i  =   0 ; i  <  threads.length; i ++ )
//  100个线程都执行完后继续
threads[i].join();
System.out.println( " n= "   +  JoinThread.n);
}
}

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

n++;

n = n + 1;

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

package  mythread;

public   class  JoinThread  extends  Thread
{
public   static int  n  =   0 ;

public static   synchronized   void  inc()
{
n ++ ;
}
public   void  run()
{
for  ( int  i  =   0 ; i  <   10 ; i ++ )
try
{
inc();  //  n = n + 1 改成了 inc();
sleep( 3 );  //  为了使运行结果更随机，延迟3毫秒

}
catch  (Exception e)
{
}
}

public   static   void  main(String[] args)  throws  Exception
{

Thread threads[]  =   new  Thread[ 100 ];
for  ( int  i  =   0 ; i  <  threads.length; i ++ )
//  建立100个线程
threads[i]  =   new  JoinThread();
for  ( int  i  =   0 ; i  <  threads.length; i ++ )
//  运行刚才建立的100个线程
threads[i].start();
for  ( int  i  =   0 ; i  <  threads.length; i ++ )
//  100个线程都执行完后继续
threads[i].join();
System.out.println( " n= "   +  JoinThread.n);
}
}

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

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

2、由于使用volatile屏蔽掉了VM中必要的代码优化，所以在效率上比较低，因此一定在必要时才使用此关键字。