volatile和synchronized的区别

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

一个变量经 volatile修饰后在所有线程中必须是同步的；任何线程中改变了它的值，所有其他线程立即获取到了相同的值。理所当然的，volatile修饰的变量存取时比一般变量消耗的资源要多一点，因为线程有它自己的变量拷贝更为高效。 

volatile只是在线程内存和“主”内存间同步某个变量的值，而synchronized通过锁定和解锁某个监视器同步所有变量的值。显然synchronized要比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. }   

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

n  =  n  +   1 ; 
n ++ ; 

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

Java代码  

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，这个就是原级别的。所以在使用volatile关键时一定要谨慎，如果自己没有把握，可以使用synchronized来代替volatile。