volatile关键字详解
文章目录
- 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;
}
@Override
public 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;
}
@Override
public 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);
}
@Override
public 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);
}
@Override
public 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;
}
@Override
public 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;
}
@Override
public 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关键字，但如果我们的问题是一个组合操作，需要用同步来解决原子性问题的话，那么可以使用原子变量。