解析java中volatilekeyword

在java多线程编程中常常volatile，有时候这个keyword和synchronized 或者lock常常有人混淆。详细解析例如以下：

在多线程的环境中会存在成员变量可见性问题: java的每一个线程都存在一个线程栈的内存空间，该内存空间保存了该线程执行时的变量信息。当线程訪问某一个变量值的时候首先会依据这个变量的地址找到对象的堆内存或者是栈堆存（原生数据类型）中的详细的内容，然后把这个内同赋值一个副本保存在本线程的线程栈中，紧接着对这个变量的一切操作在线程完毕退出之前都和堆栈内存中的变量内容是没有关系的，操作的是自己线程栈中的副本。当操作完后会把操作完的结果写回到主内存中。假如有两个线程A和B，同事操作某一个变量x;A对x进行了加1操作，那么B获取的副本可能是x加1后的结果，也可能是x；为了保证获取内存中最新的数据变量
须要加上 volatile keyword，这样在每次对x进行操作的时候都会去检查下线程栈中的变量的值是不是和住内存中变量的值一样。假设不一样会又一次load

eg:

public class ThreadSee {
//t1线程会依据flag的值做相应的操作，主线程会更改t1的值
 public static void main(String[] args) throws InterruptedException {
        ThReadTest th=  new ThReadTest();
        Thread t1 = new Thread(th);
        t1.start();
        Thread.sleep(1000);
        th.changeFlag();
        Thread.sleep(2000);
        System.out.println(th.getFlag());
    }
 
}
 
class ThReadTest implements Runnable{
 
   //线程訪问变量时会把其load到相应的线程栈中，每次操作时都要获取内存中最新的数据
    private  volatile boolean  stopflag;
    @Override
    public void run() {
        int i=0;
        while(!stopflag){
            i++;
            System.out.println("=="+Thread.currentThread().getName());
        }
        System.out.println("Thread finish:"+i);
    }
    public void changeFlag(){
        this.stopflag=true;
        System.out.println(Thread.currentThread().getName()+"***********");
    }
 
    public boolean getFlag(){
        return stopflag;
    }
}

上述代码假设去掉volatile,会一直死循环运行下去。

可是volatile不能保证线程安全的同步

eg:

public class ThreadSave implements Runnable{
    static ThreadSave sync = new ThreadSave();
    static volatile int j=0;
    //Lock  lock =new ReentrantLock();
    public  void inscane(){
       // lock.lock();
        for(int i=0;i<10000000;i++){
            j++;
        }
     //   lock.unlock();
    }
    @Override
    public void run() {
        inscane();
    }
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(sync);
        Thread t2 = new Thread(sync);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(j);
    }
}

依据上述代码运行的结果不是预期20000000，

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

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

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

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

导致两个线程及时用volatilekeyword改动之后，还是会存在并发的情况。

综上所述：

volatile仅仅会保证线程去做一个检查当前线程栈的变量值和主内存中数据值是否一样的这么一个动作。仅仅此而已。而lock或者是synchronized 会保证某一时刻仅仅有单个线程进入该方法，从而确保其线程安全性。

所以在假设多个线程去改动一个volatile变量那么没有实际的逻辑意义。假设一个线程去改动其它的线程依赖改动的变量值，此时是有作用的