首页 > 基础教程 > 关键字 > volatile关键字

Java volatile的例子和用法

下面通过2个Java volatile的例子来详细说明volatile的用法

1. 实例一 

public class VolatileTest extends Thread {
    boolean flag = false;
    int i = 0;
    
    public void run() {
        while (!flag) {
            i++;
        }
    }
    
    public static void main(String[] args) throws Exception {
        VolatileTest vt = new VolatileTest();
        vt.start();
        Thread.sleep(2000);
        vt.flag = true;
        System.out.println("stope" + vt.i);
    }
}

上面的代码是通过标记flag来控制VolatileTest线程while循环退出的例子!

下面让我用伪代码来描述一下我们的程序

  • 首先创建 VolatileTest vt = new VolatileTest();
  • 然后启动线程 vt.start();
  • 暂停主线程2秒（Main） Thread.sleep(2000);
  • 这时的vt线程已经开始执行，进行i++;
  • 主线程暂停2秒结束以后将 vt.flag = true;
  • 打印语句 System.out.println("stope" + vt.i); 在此同时由于vt.flag被设置为true,所以vt线程在进行下一次while判断 while (!flag) 返回假 结束循环 vt线程方法结束退出！
  • 主线程结束

上面的叙述看似并没有什么问题，“似乎”完全正确。那就让我们把程序运行起来看看效果吧，执行mian方法。2秒钟以后控制台打印stope-202753974。

可是奇怪的事情发生了 程序并没有退出。vt线程仍然在运行，也就是说我们在主线程设置的 vt.flag = true;没有起作用。

问题出现了，为什么我在主线程（main）中设置了vt.flag = true; 而vt线程在进行判断flag的时候拿到的仍然是false?


首先 vt线程在运行的时候会把 变量 flag 与 i (代码3,4行)从“主内存”  拷贝到 线程栈内存（上图的线程工作内存）

然后 vt线程开始执行while循环 

  

 7 while (!flag) { 8             i++; 9         }

while (!flag)进行判断的flag 是在线程工作内存当中获取，而不是从 “主内存”中获取。

i++; 将线程内存中的i++; 加完以后将结果写回至 "主内存"，如此重复。

然后再说说主线程的执行过程。 我只说明关键的地方 

vt.flag = true;

主线程将vt.flag的值同样 从主内存中拷贝到自己的线程工作内存 然后修改flag=true. 然后再将新值回到主内存。

这就解释了为什么在主线程（main）中设置了vt.flag = true; 而vt线程在进行判断flag的时候拿到的仍然是false。那就是因为vt线程每次判断flag标记的时候是从它自己的“工作内存中”取值，而并非从主内存中取值！

这也是JVM为了提供性能而做的优化。那我们如何能让vt线程每次判断flag的时候都强制它去主内存中取值呢。这就是volatile关键字的作用。

再次修改我们的代码： 

public class VolatileTest extends Thread {
    
    volatile boolean flag = false;
    int i = 0;
    
    public void run() {
        while (!flag) {
            i++;
        }
    }
    
    public static void main(String[] args) throws Exception {
        VolatileTest vt = new VolatileTest();
        vt.start();
        Thread.sleep(2000);
        vt.flag = true;
        System.out.println("stope" + vt.i);
    }
}

在flag前面加上volatile关键字，强制线程每次读取该值的时候都去“主内存”中取值。在试试我们的程序吧，已经正常退出了。


2. 实例二

我们实现一个计数器，每次线程启动的时候，会调用计数器inc方法，对计数器进行加一

  1. package com.volatiles.demo;  
  2.   
  3. public class VolatileTest {  
  4.   
  5.     private int data = 0;  
  6.       
  7.     public static void main(String[] args) throws Exception{  
  8.           
  9.         final VolatileTest obj = new VolatileTest();  
  10.         //创建1000个线程对变量data进行加1操作  
  11.         for(int i=0;i<1000;i++){  
  12.             new Thread(){  
  13.                 @Override  
  14.                 public void run(){  
  15.                     try{  
  16.                         Thread.sleep(1);  
  17.                         obj.data++;  
  18.                     }catch(Exception e){  
  19.                         e.printStackTrace();  
  20.                     }  
  21.                 }  
  22.             }.start();  
  23.         }  
  24.         //打印结果  
  25.         System.out.println("data:"+obj.data);  
  26.           
  27.     }  
  28.   
  29. }  
运行结果:data:995

实际运算结果每次可能都不一样，本机的结果为：运行结果:data:995，可以看出，在多线程的环境下，data并没有期望结果是1000 

很多人以为，这个是多线程并发问题，只需要在变量data之前加上volatile就可以避免这个问题，那我们在修改代码看看，看看结果是不是符合我们的期望 :
运行结果:data:992

运行结果还是没有我们期望的1000，下面我们分析一下原因

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


Java volatile

描述这一过程：
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关键字修改之后，还是会存在并发的情况。



版权声明：本文为JAVASCHOOL原创文章，未经本站允许不得转载。