恐怕比较一下volatile和synchronized的不同是最容易解释清楚的。volatile是变量修饰符，而synchronized则作用于一段代码或方法；看如下三句get代码：

int i1; int geti1() {return i1;} volatile int i2; int geti2() {return i2;} int i3; synchronized int geti3() {return i3;} geti1() int i1; int geti1() {return i1;} volatile int i2; int geti2() {return i2;} int i3; synchronized int geti3() {return i3;} geti1()

　　得到存储在当前线程中i1的数值。多个线程有多个i1变量拷贝，而且这些i1之间可以互不相同。换句话说，另一个线程可能已经改变了它线程内的i1值，而这个值可以和当前线程中的i1值不相同。事实上，Java有个思想叫“主”内存区域，这里存放了变量目前的“准确值”。每个线程可以有它自己的变量拷贝，而这个变量拷贝值可以和“主”内存区域里存放的不同。因此实际上存在一种可能：“主”内存区域里的i1值是1，线程1里的i1值是2，线程2里的i1值是3——这在线程1和线程2都改变了它们各自的i1值，而且这个改变还没来得及传递给“主”内存区域或其他线程时就会发生。

　　而 geti2()得到的是“主”内存区域的i2数值。用volatile修饰后的变量不允许有不同于“主”内存区域的变量拷贝。换句话说，一个变量经 volatile修饰后在所有线程中必须是同步的；任何线程中改变了它的值，所有其他线程立即获取到了相同的值。理所当然的，volatile修饰的变量存取时比一般变量消耗的资源要多一点，因为线程有它自己的变量拷贝更为高效。

　　既然volatile关键字已经实现了线程间数据同步，又要 synchronized干什么呢？呵呵，它们之间有两点不同。首先，synchronized获得并释放监视器——如果两个线程使用了同一个对象锁，监视器能强制保证代码块同时只被一个线程所执行——这是众所周知的事实。但是，synchronized也同步内存：事实上，synchronized在“ 主”内存区域同步整个线程的内存。因此，执行geti3()方法做了如下几步：

　　1. 线程请求获得监视this对象的对象锁（假设未被锁，否则线程等待直到锁释放）

　　2. 线程内存的数据被消除，从“主”内存区域中读入（Java虚拟机能优化此步。。。[后面的不知道怎么表达,汗]）

　　3. 代码块被执行

　　4. 对于变量的任何改变现在可以安全地写到“主”内存区域中（不过geti3()方法不会改变变量值）

　　5. 线程释放监视this对象的对象锁

　　因此volatile只是在线程内存和“主”内存间同步某个变量的值，而synchronized通过锁定和解锁某个监视器同步所有变量的值。显然synchronized要比volatile消耗更多资源。

　　=========================分割线3=================================

　　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); } } 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  +   1 ;

　　n ++ ;

　　如果要想使这种情况变成原子操作，需要使用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); } } 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。

最新内容请见作者的GitHub页：http://qaseven.github.io/