文章目录

1 volatile作用
2 volatile非原子的特性
3 原子类也并不完全安全
4 原子类和volatile区别

1 volatile作用

volatile关键字的主要作用是使变量在多个线程间可见，方式是强制性从公共堆栈中进行取值。

先看个例子：

public class RunThread extends Thread{private boolean isRunning = true;public boolean isRunning() {return isRunning;}public void setRunning(boolean running) {isRunning = running;}@Overridepublic void run() {System.out.println("进入 run 了");while (isRunning == true){}System.out.println("线程被停止了");}
}

public class TestMain {public static void main(String[] args) {try {RunThread thread = new RunThread();thread.start();Thread.sleep(1000);thread.setRunning(false);System.out.println("已经赋值为false");}catch (InterruptedException e){e.printStackTrace();}}
}

运行结果如下：

程序会一直运行下去，造成死循环。因为在启动RunThread.java 线程时，变量private boolean isRunning = true;存在于公共堆栈及线程的私有堆栈中。线程一直在私有堆栈中取得isRunning的值是true。而代码thread.setRunning(false) 虽然被执行，更新的确实公共堆栈中的isRunning变量值false，所以一直就是死循环状态。内存结构如下图所示：

线程的私有堆栈

这个问题是私有堆栈中的值和公共堆栈中的值不同不造成的。解决这样的问题就要使用volatile关键字了，它主要的作用就是当线程访问isRunning这个变量时，强制性从公共堆栈中进行取值。

更改后RunThread.java 代码如下：

public class RunThread extends Thread{volatile private boolean isRunning = true;public boolean isRunning() {return isRunning;}public void setRunning(boolean running) {isRunning = running;}@Overridepublic void run() {System.out.println("进入 run 了");while (isRunning == true){}System.out.println("线程被停止了");}
}

public class TestMain {public static void main(String[] args) {try {RunThread thread = new RunThread();thread.start();Thread.sleep(1000);thread.setRunning(false);System.out.println("已经赋值为false");}catch (InterruptedException e){e.printStackTrace();}}
}

运行结果如下：

通过使用volatile关键字，强制的从公共内存中读取变量的值，内存结构如下图所示

读取公共内存

使用volatile关键字增加了实例变量在多个线程之间的可见性。但volatile关键字最致命的缺点是不支持原子性。

原子性(Atomicity)：指事务的不可分割性，一个事物的所有操作要么不间断地全部被执行，要么一个也没有执行。

2 volatile非原子的特性

示例如下：

public class MyThread extends Thread{volatile public static int count;private static void addCount(){for (int i =0; i < 1000; i++){count++;}System.out.println("count =  " + count);}@Overridepublic void run() {addCount();}
}

public class TestRun {public static void main(String[] args) {MyThread[] arr = new MyThread[100];for (int i = 0; i < 100; i++){arr[i] = new MyThread();}for (int j = 0; j < 100; j++){arr[j].start();}}
}

运行结果如下：

更改MyThread.java 文件代码如下：

public class MyThread extends Thread{volatile public static int count;//注意一定要添加static关键字//这样synchronized与static锁的内容就是MyThread.class 类了，也就达到同步的效果了。synchronized private static void addCount(){for (int i =0; i < 1000; i++){count++;}System.out.println("count =  " + count);}@Overridepublic void run() {addCount();}
}

public class TestRun {public static void main(String[] args) {MyThread[] arr = new MyThread[100];for (int i = 0; i < 100; i++){arr[i] = new MyThread();}for (int j = 0; j < 100; j++){arr[j].start();}}
}

运行结果如下：

在本示例中，如果在方法private static void addCount()前加入synchronized同步关键字，也就没有必要再使用volatile关键字来声明count变量了。

关键字volatile主要使用的场合是在多个线程中可以感知实例变量被更改了，并且可以获得最新的值使用，也就是用多线程读取共享变量时可以获得最新值使用。

关键字volatile提示线程每次从共享内存中读取变量，而不是从私有内存中读取，这样就保证了同步数据的可见性。但在这里需要注意的是：如果修改实例变量中的数据，比如i++，也就是i= i+1，则这样的操作其实并不是一个原子操作，也就是非线程安全的。表达式i++的操作步骤分解如下：

1 从内存中取出i的值

2 计算i的值

3 将i的值写到内存中

假如在第二步计算值的时候，另外一个线程也修改i的值，那么这个时候就会出现脏数据。解决的办法其实就是使用synchronized关键字。所以说volatile本身并不处理数据的原子性，而是强制对数据的读写及时影响到主内存的。

用图演示关键字volatile出现非线程安全的原因，变量在内存中工作的过程如下图所示。

可以得出以下结论：

1 read 和 load 阶段：从主存复制变量到当前线程工作内存；

2 use 和 assign 阶段：执行代码，改变共享变量值。

3 store 和 write 阶段：用工作内存数据刷新主存对应变量的值。

在多线程环境中，use 和 assign 是多次出现的，但这一操作并不是原子性，也就是在read 和 load 之后，如果主内存count变量发生修改之后，线程工作内存中的值由于已经加载，不会产生对应的变化，也就是私有内存和公共内存中的变量不同步，所以计算出来的结果会和预期不一样，也就出现了非线程安全问题。

对于用volatile修饰的变量，jvm虚拟机只是保证从主内存加载到线程工作内存的值是最新的。例如线程1和线程2在进行read和load的操作中，发现主内存中count的值都是5，那么都会加载这个最新的值。也就是说，volatile关键字解决的是变量读时的可见性问题，但无法保证原子性，对于多个线程访问同一个实例变量还是需要加锁同步。

3 原子类也并不完全安全

示例如下

public class MyService {public static AtomicLong al = new AtomicLong();public void addNum(){System.out.println(Thread.currentThread().getName() + " 加了100 之后的值是 ： " + al.addAndGet(100));al.addAndGet(1);}
}

public class MyThread extends Thread{private MyService myService;public MyThread(MyService myService) {this.myService = myService;}@Overridepublic void run() {super.run();myService.addNum();}
}

public class TestRun {public static void main(String[] args) {try {MyService service = new MyService();MyThread[] array = new MyThread[5];for (int i = 0; i< array.length; i++){array[i] = new MyThread(service);}for (int j = 0; j <array.length; j++){array[j].start();}Thread.sleep(1000);System.out.println(service.al.get());}catch (InterruptedException e){e.printStackTrace();}}
}

运行结果如下：

打印顺序出错了，应该每加1次100再加一次1.出现这样的情况是因为addAndGet()方法是原子的，但方法和方法之间的调用却不是原子的。

更改后的代码如下：

public class MyService {public static AtomicLong al = new AtomicLong();synchronized public void addNum(){System.out.println(Thread.currentThread().getName() + " 加了100 之后的值是 ： " + al.addAndGet(100));al.addAndGet(1);}
}

public class MyThread extends Thread{private MyService myService;public MyThread(MyService myService) {this.myService = myService;}@Overridepublic void run() {super.run();myService.addNum();}
}

public class TestRun {public static void main(String[] args) {try {MyService service = new MyService();MyThread[] array = new MyThread[5];for (int i = 0; i< array.length; i++){array[i] = new MyThread(service);}for (int j = 0; j <array.length; j++){array[j].start();}Thread.sleep(1000);System.out.println(service.al.get());}catch (InterruptedException e){e.printStackTrace();}}
}

运行结果如下：

从运行结果可以看到，是每次加100再加1，这就是我们想要得到的过程，结果是505的同时还保证在过程中累加的顺序也是正确的。

4 原子类和volatile区别

volatile 和原子类的使用场景是不一样的，如果我们有一个可见性问题，那么可以使用volatile关键字，但如果我们的问题是一个组合操作，需要用同步来解决原子性问题的话，那么可以使用原子变量。

volatile关键字详解相关推荐

并发编程系列之volatile关键字详解
并发编程系列之volatile关键字详解 1.volatile是什么? 首先简单说一下,volatile是什么?volatile是Java中的一个关键字,也是一种同步机制.volatile为了保证变量 ...
java中实现具有传递性吗_Java中volatile关键字详解,jvm内存模型，原子性、可见性、有序性...
一.Java内存模型想要理解volatile为什么能确保可见性,就要先理解Java中的内存模型是什么样的. Java内存模型规定了所有的变量都存储在主内存中.每条线程中还有自己的工作内存,线程的工作 ...
C语言volatile关键字详解
volatile提醒编译器它后面所定义的变量随时都有可能改变,因此编译后的程序每次需要存储或读取这个变量的时候,都会直接从变量地址中读取数据.如果没有volatile关键字,则编译器可能优化读取和存储 ...
C/C++中volatile关键字详解
1. 为什么用volatile? C/C++ 中的 volatile 关键字和 const 对应,用来修饰变量,通常用于建立语言级别的 memory barrier.这是 BS 在 "The ...
Java volatile关键字详解
1.关于volatile volatile是Java语言中的关键字,用来修饰会被多线程访问的共享变量,是JVM提供的轻量级的同步机制,相比同步代码块或者重入锁有更好的性能.它主要有两重语义,一是保证多 ...
volatile 关键字详解
volatile,可以当之无愧的被称为Java并发编程中"出现频率最高的关键字",常用于保持内存可见性和防止指令重排序. 保持内存可见性内存可见性(Memory Visibili ...
Java并发编程：volatile关键字详解
volatile关键字两大特性:线程可见性/禁止指令重排序原理:由jvm实现的一条汇编质量lock 要知道为什么会能保证线程的可见性,先要了解jmm的原子操作假设一个变量initFlag默认为fa ...
java中volatile_Java中Volatile关键字详解
一.基本概念先补充一下概念:Java并发中的可见性与原子性可见性: 可见性是一种复杂的属性,因为可见性中的错误总是会违背我们的直觉.通常,我们无法确保执行读操作的线程能适时地看到其他线程写入的值, ...
Java——volatile关键字详解
关注微信公众号:CodingTechWork,一起学习进步. volatile介绍 volatile概述 volatile是比synchronized关键字更轻量级的同步机制,访问volatile变量 ...

volatile关键字详解

文章目录

1 volatile作用

2 volatile非原子的特性

3 原子类也并不完全安全

4 原子类和volatile区别

volatile关键字详解相关推荐

最新文章

热门文章