java并发中的volatile和synchronized

  今天使用到了volatile关键字，以前了解到这个关键字，可是不知道他的具体做用是什么，下面就来详细解释一下他的做用：

在java线程并发处理中，有一个关键字volatile的使用目前存在很大的混淆，觉得使用这个关键字，在进行多线程并发处理的时候就能够万事大吉。
Java语言是支持多线程的，为了解决线程并发的问题，在语言内部引入了 同步块(synchronized) 和 volatile 关键字机制。

synchronized 
同步块你们都比较熟悉，经过 synchronized 关键字来实现，全部加上synchronized 和 块语句，在多线程访问的时候，同一时刻只能有一个线程可以用synchronized 修饰的方法 或者 代码块。

volatile
用volatile修饰的变量，线程在每次使用变量的时候，都会读取变量修改后的最新的值。volatile很容易被误用，用来进行原子性操做。
下面看一个例子，咱们实现一个计数器，每次线程启动的时候，会调用计数器inc方法，对计数器进行加一

 

public static void main(String[] args) throws Exception{
    final VolatileTest obj = new VolatileTest();
    //建立1000个线程对变量data进行加1操做
    for(int i=0;i<1000;i++){
        new Thread(){
            @Override
            public void run(){
                try{
                    Thread.sleep(1);
                    obj.data++;
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
        }.start();
    }
    //打印结果
    System.out.println("data:"+obj.data);
}

 

运行结果:data:995

实际运算结果每次可能都不同，本机的结果为：运行结果:data:995，能够看出，在多线程的环境下，data并无指望结果是1000 

不少人觉得，这个是多线程并发问题，只须要在变量data以前加上volatile就能够避免这个问题，那咱们在修改代码看看，看看结果是否是符合咱们的指望 :
运行结果:data:992

运行结果仍是没有咱们指望的1000，下面咱们分析一下缘由

咱们都知道jvm运行时刻内存的分配。其中有一个内存区域是jvm虚拟机栈，每个线程运行时都有一个线程栈，线程栈保存了线程运行时候变量值信息。当线程访问某一个对象时候值的时候，首先经过对象的引用找到对应在堆内存的变量的值，而后把堆内存变量的具体值load到线程本地内存中，创建一个变量副本，以后线程就再也不和对象在堆内存变量值有任何关系，而是直接修改副本变量的值，在修改完以后的某一个时刻（线程退出以前），自动把线程变量副本的值回写到对象在堆中变量。这样在堆中的对象的值就产生变化了。下面一幅图

 

描述这一过程：
read and load  从主存复制变量到当前工做内存
use and assign   执行代码，改变共享变量值 
store and write  用工做内存数据刷新主存相关内容

其中use and assign 能够屡次出现
可是这一些操做并非原子性，也就是 在read load以后，若是主内存data变量发生修改以后，线程工做内存中的值因为已经加载，不会产生对应的变化，因此计算出来的结果会和预期不同。

 

对于volatile修饰的变量，jvm虚拟机只是保证从主内存加载到线程工做内存的值是最新的
例如假如线程1，线程2 在进行read,load 操做中，发现主内存中data的值都是5，那么都会加载这个最新的值
在线程1对data进行修改以后，会write到主内存中，主内存中的data变量就会变为6
线程2因为已经进行read,load操做，在进行运算以后，也会更新主内存data的变量值为6
致使两个线程及时用volatile关键字修改以后，仍是会存在并发的状况。

 

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

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

 恐怕比较一下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()获得存储在当前线程中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消耗更多资源。 
一个变量声明为volatile，就意味着这个变量是随时会被其余线程修改的，所以不能将它cache在线程memory中。

博客地址：http://my.oschina.net/wangnian