volatile在多线程中的使用

volatile

volatile修饰的变量，线程每次使用变量时，都会读取变量修改后的最新值，但volatile并不表示原子性操作，它只能保证该变量被修改后马上更新到主存（即保证下一个要读取的线程可以读取到最新值），若是之前已经被其他线程读取到线程的工作内存，那么该变量是不会更新过去的，看如下程序：

public class volatileTest {
    public static int count = 0;

    public static void inc() {

        //这里延迟1毫秒，使得结果明显
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {
        }

        count++;
        System.out.println(Thread.currentThread().getName()+",运行结果:count=" + volatileTest.count);
    }

    public static void main(String[] args) {

        //同时启动1000个线程，去进行i++计算，看看实际结果

        for (int i = 0; i < 1000; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    volatileTest.inc();
                }
            }).start();
        }

        try {
            Thread.sleep(20000);
            System.out.println("运行结果:Counter.count=" + volatileTest.count);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }   
    }
}

运行结果为：

原因是因为有多个线程访问count，而该count可能在被修改前，转到其他线程进行访问，因此出现了多个993,999的值，这是并发访问中常见的问题，所以出现了synchronized和Lock类来进行对象的同步防止数据异常。

接下来再来看volatile:

public class volatileTest {
    public volatile static int count = 0;

    public static void inc() {

        //这里延迟1毫秒，使得结果明显
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {
        }

        count++;
        System.out.println(Thread.currentThread().getName()+",运行结果:count=" + volatileTest.count);
    }

    public static void main(String[] args) {

        //同时启动1000个线程，去进行i++计算，看看实际结果

        for (int i = 0; i < 1000; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    volatileTest.inc();
                }
            }).start();
        }
    }
}

结果：

仍然有问题，分析原因是：
因为count虽然为volatile域，可以做到更新的值马上传递到主存，但是由于在上述的inc()方法中，count++并不是原子性操作，可能在进行加1的过程中，即加1的过程还没结束，其他线程开始读取count当前数值（因此读取到的仍是旧值），导致volatile失去了作用（个人理解，请指正）。

/* 以下内容是对volatile的理解
但是volatile还是有作用的，作用在哪？如果count加1使用原子性操作，volatile域的作用是什么？线程0和线程1都读取到count为0的初值，然后线程0进行count加1（原子性操作），然后线程1进行count+1，在线程1完成该原子性操作之后，线程1中的count是1还是2？若是2是不是就是volatile和普通static变量的区别？
查阅资料，解决了：
volatile可以保证共享变量在其他线程的工作内存中变化后马上更新到主存，然后当其他线程要读取该共享变量时，能在主存读取到最新的值，但是普通变量若在线程0的工作内存中变化后是不知道什么时候才会更新到主存的，所以又其他线程，如线程1要读取该普通变量，还是读到的旧值，不过对于已经读取共享变量到工作内存的线程来说，该值是不会变的，如线程2和线程0都读取了volatile修饰的共享变量count为0，此时线程0完成count加1的原子性操作，主存中会马上更新，此时线程1再来读取count时可以读到count为1，而线程2中读取的count仍为0。

而如何保证count操作正确呢？即1000个线程对count++，不用同步或锁，得到最后count为1000？把count++操作改成原子性操作即可，借鉴他人代码：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class volatileTest {
//  public volatile static int count = 0;

    public static AtomicInteger count = new AtomicInteger(0);

    public static void inc() {

//      count++;
        count.incrementAndGet();
        System.out.println(Thread.currentThread().getName()+",count="+count);
    }

    public static void main(String[] args) throws InterruptedException {      
        ExecutorService service=Executors.newFixedThreadPool(Integer.MAX_VALUE);

        for (int i = 0; i < 1000; i++) {
            service.execute(new Runnable() {
                @Override
                public void run() {
                    volatileTest.inc();
                }
            });
        }

        service.shutdown();
        //给予一个关闭时间（timeout），但是实际关闭时间应该会这个小
        service.awaitTermination(20,TimeUnit.SECONDS);       
        System.out.println("运行结果:Counter.count=" + volatileTest.count);
    }
}

结果：

这个结果是正确的，思路也应当是对的。
至此其实已经解决了atomic类的特点对不采用同步且防止多线程带来的数据异常问题了。
原子类为什么可以保证及时更新，不需要volatile关键字呢？因为其内部其实是一个volatile的域，所以不需要在外面加该关键字了
AtomicInteger源码（参考 http://wentao365.iteye.com/blog/1789750）

private volatile int value;  

关于volatile的资料：
volatile具有synchronized关键字的“可见性”，但是没有synchronized关键字的“并发正确性”，也就是说不保证线程执行的有序性。

也就是说，volatile变量对于每次使用，线程都能得到当前volatile变量的最新值。但是volatile变量并不保证并发的正确性。

看下面的例子：

假如count变量是volatile的。线程1，线程2 在进行read,load 操作中，发现主内存中count的值都是5，那么都会加载这个最新的值在线程1堆count进行修改之后，会write到主内存中，主内存中的count变量就会变为6，线程2由于已经进行read,load操作，在进行运算之后，也会更新主内存count的变量值为6，导致两个线程及时用volatile关键字修改之后，还是会存在并发的情况。

在 java 垃圾回收整理一文中，描述了jvm运行时刻内存的分配。其中有一个内存区域是jvm虚拟机栈，每一个线程运行时都有一个线程栈，

线程栈保存了线程运行时候变量值信息。当线程访问某一个对象时候值的时候，首先通过对象的引用找到对应在堆内存的变量的值，然后把堆内存

变量的具体值load到线程本地内存中，建立一个变量副本，之后线程就不再和对象在堆内存变量值有任何关系，而是直接修改副本变量的值，

在修改完之后的某一个时刻（线程退出之前），自动把线程变量副本的值回写到对象在堆中变量。这样在堆中的对象的值就产生变化了。下面一幅图

描述这写交互（描述的是非原子性的操作，若是原子性操作加上volatile，如基本类型变量赋值，主存中该变量会立即更新，以供外界读取最新值）

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

其中use and assign 可以多次出现

但是这一些操作并不是原子性，也就是 在read load之后，如果主内存count变量发生修改之后，线程工作内存中的值由于已经加载，不会产生对应的变化，所以计算出来的结果会和预期不一样

对于volatile修饰的变量，jvm虚拟机只是保证从主内存加载到线程工作内存的值是最新的

例如假如线程1，线程2 在进行read,load 操作中，发现主内存中count的值都是5，那么都会加载这个最新的值

在线程1堆count进行修改之后，会write到主内存中，主内存中的count变量就会变为6

线程2由于已经进行read,load操作，在进行运算之后，也会更新主内存count的变量值为6

导致两个线程及时用volatile关键字修改之后，还是会存在并发的情况。

参考：
http://www.cnblogs.com/dolphin0520/p/3920373.html