资讯专栏INFORMATION COLUMN

上云采购季！| 爆款云服务器低至4.6元/月，首单享0.9折

免费试用
首页/文章专栏/猫头鹰的深夜翻译：Volatile的原子性, 可见性和有序性

猫头鹰的深夜翻译：Volatile的原子性, 可见性和有序性

Lionad-Morotar / 2011人阅读

摘要：有可能一个线程中的动作相对于另一个线程出现乱序。当实际输出取决于线程交错的结果时，这种情况被称为竞争条件。这里的问题在于代码块不是原子性的，而且实例的变化对别的线程不可见。这种不能同时在多个线程上执行的部分被称为关键部分。

为什么要额外写一篇文章来研究volatile呢？是因为这可能是并发中最令人困惑以及最被误解的结构。我看过不少解释volatile的博客，但是大多数要么不完整，要么难以理解。我会从并发中最重要的一些因素开始说起：

原子性
原子性是不可分割的操作。它们要么全部实现，要么全部不实现。Java中原子操作的最佳例子是将一个值赋给变量。

可见性
可见性是指：无论是哪个线程对一个共享的变量作出的修改或是带来的影响，读其他的线程都是可见的。

有序性
有序性是指源码中指令是否会被编译器出于优化而改变执行顺序。有可能一个线程中的动作相对于另一个线程出现乱序。

现在举一个例子来理解这些因素：

public class MyApp
{
    private int count = 0;
    public void upateVisitors() 
    {
       ++count; //increment the visitors count
    }
}

Hint: read-modify-write

这一段代码中有一个试图更新应用（网页）的访客数量的方法。这段代码的问题在于++count指令不是原子性的，它包含三条独立的指令：

temp = count;   (read)
temp = temp + 1;   (modify)
count = temp;  (write)

因此，当一个线程正在执行此操作时，此指令可以被另一个线程预占。从而不是原子性操作。假设count的值为10，并且有如下的执行顺序：

我们会发现：在某个很不巧合的时刻，两个线程同时读取到了值（10），然后彼此将其值加一。所以在这个过程有一个递增的操作丢失了。当实际输出取决于线程交错的结果时，这种情况被称为竞争条件（race condition）。这里丢失了一次递增。那么并发的哪些方面在这里缺失了？原子性。再考虑一个创建单例的例子（当然也是不好的例子）：

public Singleton getInstance()
{
   if(_instance == null)
   { 
      _instance = new Singleton();
   }
}

Hint: check-then-act

再一次的，可能有两个线程都判断这实例为null，并且都进入了if代码块。这会导致两个实例的创建。这里的问题在于代码块不是原子性的，而且实例的变化对别的线程不可见。这种不能同时在多个线程上执行的部分被称为关键部分（critical section）。对于关键部分，我们需要使用synchronized块和synchronized方法。

还是原子性
为了确保原子性，我们通常使用锁来确保互斥。参考下面的例子，一个银行账户使用synchronized方法上锁。

class BankAccount {
 private int accountBalance;
 synchronized int getAccountBalance() {
    return accountBalance;  
 }
 synchronized void setAccountBalance(int b) throws IllegalStateException {
    accountBalance = b;
    if (accountBalance < 0) {
     throw new IllegalStateException("Sorry but account has negative Balance");
    }
 }
 void depositMoney(int amount) {
    int balance = getAccountBalance();
    setAccountBalance(balance + amount);
 }
 void withdrawMoney(int amount) {
    int balance = getAccountBalance();
    setAccountBalance(balance - amount);
 }
}

对共享变量balance的访问通过锁来保护，从而数据竞争不会有问题。这个类有问题吗？是有的。假设一个线程调用depositMoney(50)而另一个线程调用withdrawMoney(50)，并且balance的初始值为100。理想情况下操作完成后balance应该为0。但是我们无法保证得到这个结果：

depositMoney操作读取的balance值为100

withdrawMoney操作读取的balance值也是100，它在此基础上减去50元并将其设为50元。

最终depositMoney在之前看到的balance值的基础上加上50，并将其设为150。

再次因为没有保证原子性而丢失了一个更新。如果两种方法都被声明为同步，则将在整个方法期间确保锁定，并且改变将以原子方式进行。

再谈可见性
如果一个线程的操作对另一个线程可见，那么其他线程也会观察到它的所有操作的结果。考虑下面的例子：

public class LooperThread extends Thread
{
    private boolean isDone = false;
    public void run() 
    {
       while( !isDone ) {
          doSomeWork();
       }
    }
    public void stopWork() {
       isDone = true;
    }
}

这里缺失了什么？假设LooperThread的一个实例正在运行，主线程调用了stopWord来中止它。这两个线程之间没有实现同步。编译器会以为在第一个线程中没有对isDone执行写入操作，并且决定只读入isDone一次。于是，线程炸了！部分JVM可能会这样做，从而使其变成无限循环。因此答案显然是缺乏可见性。

再谈有序性
有序性是关于事情发生的顺序。考虑下面的例子：

在上述情况下，线程2能打印出value = 0吗？其实是有可能的。在编译器重新排序中result=true可能会在value=1之前出现。value = 1也可能不对线程2可见，然后线程2将加载value = 0。我们可以使用volatile解决这个问题吗？

CPU架构（多层RAMs）
CPU现在通常多核，并且线程将在不同核心上运行。另外还有不同级别的高速缓存，如下图所示：

当一个volatile变量被任何线程写入一个特定的核心，所有其他核心的值都需要更新，因为每个核心都有其自己的缓存，该缓存内有变量的旧值。消息传递给所有内核以更新值。

volatile
根据Java文档，如果一个变量被声明为volatile，那么Java内存模型（在JDK 5之后）确保所有线程都看到变量的一致值。volatile就像是synchronized的一个亲戚，读取volatile数据就像是进入一个synchronized块，而写入volatile数据就像是从synchronized块中离开。当写入一个volatile值时，这个值直接写入主存而不是本地处理器的缓存，并且通过发送消息提醒其它内核的缓存该值的更新。Volatile不是原子性操作

volatile保证顺序性和可见性但是不保证互斥或是原子性。锁能保证原子性，可视性和顺序性。所以volatile不能代替synchronized。

volatile读与写
volatile提供了顺序性保障，这意味着编译器生成的指令不能以实际源代码指令定义的顺序以外的其他顺序执行操作结果。尽管生成的指令的顺序可能与源代码的原始顺序不同，但所产生的效果必须相同。我们还需要从Java Doc中观察以下关于读写的内容：

当一个线程读取一个volatile变量时，它不仅会看到volatile的最新变化，还会看到导致变化的代码的副作用。

我们需要了解以下有关读写volatile的内容:

当一个线程写入一个volatile变量，另一个线程看到写入，第一个线程会告诉第二个线程关于内存变化的内容，直到它执行写入该volatile变量。

在这里，线程2看到了线程1的内容。

我们可以声明 final 类型的volatile变量吗？
如果一个变量是final的，我们不能改变它的值，volatile就是确保对其他线程可见的共享变量的更改。所以这是不允许的，并会导致编译错误。

为什么我们在并发编程中声明long / double为volatile？
默认情况下long/double的读写不是原子性的。非原子性的double/long写操作会被当做两个写入操作：分别写入前32位和后32位。它可能会导致一个线程看到另一个线程写入的64位值的前32位，而第二个线程看到来自另一个线程写入的后32位。读写volatile的long/double类型变量总是原子性的。

Volatile vs Atomic类

public class MyApp
{
    private volatile int count = 0;
    public void upateVisitors() 
    {
       ++count; //increment the visitors count
    }
}

如果我们将count声明为atomic，这段代码可以正常运行吗？可以的，而且当对变量进行增加或减少操作时，最好使用atomic类。AtomicInteger通常使用volatile或是CAS来实现线程安全。


想要了解更多开发技术，面试教程以及互联网公司内推，欢迎关注我的微信公众号！将会不定期的发放福利哦~

海外云主机 GPU服务器 可见性 原子性 服务可见性 java并发可见性

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/68804.html

相关文章

  • 猫头鹰的深夜翻译：核心JAVA并发(一)

    摘要：简介从创建以来，就支持核心的并发概念如线程和锁。这篇文章会帮助从事多线程编程的开发人员理解核心的并发概念以及如何使用它们。请求操作系统互斥，并让操作系统调度程序处理线程停放和唤醒。 简介 从创建以来，JAVA就支持核心的并发概念如线程和锁。这篇文章会帮助从事多线程编程的JAVA开发人员理解核心的并发概念以及如何使用它们。 （博主将在其中加上自己的理解以及自己想出的例子作为补充） 概念 ...

    Richard_Gao 评论0 收藏0

  • 猫头鹰的深夜翻译：Java中的CAS(Compare And Swap)

    摘要：否则它就会用新的值替代当前值。在这种情况下，锁可能会优于原子变量，但在实际的争用级别中，原子变量的性能优于锁。在中引入了另外一个构件。 题目要求 在我们深入了解CAS(Compare And Swap)策略以及它是如何在AtomicInteger这样的原子构造器中使用的，首先来看一下这段代码： public class MyApp { private volatile int ...

    hosition 评论0 收藏0

  • 浅谈Java并发编程系列（四）—— 原子性、可见性与有序性

    摘要：内存模型是围绕着在并发过程中如何处理原子性可见性和有序性这个特征来建立的，我们来看下哪些操作实现了这个特性。可见性可见性是指当一个线程修改了共享变量的值，其他线程能够立即得知这个修改。 Java内存模型是围绕着在并发过程中如何处理原子性、可见性和有序性这3个特征来建立的，我们来看下哪些操作实现了这3个特性。 原子性（atomicity）： 由Java内存模型来直接保证原子性变量操作包括...

    tianren124 评论0 收藏0

  • 死磕 java同步系列之volatile解析

    摘要：前半句是指线程内表现为串行的语义，后半句是指指令重排序现象和工作内存和主内存同步延迟现象。关于内存模型的讲解请参考死磕同步系列之。目前国内市面上的关于内存屏障的讲解基本不会超过这三篇文章，包括相关书籍中的介绍。问题 （1）volatile是如何保证可见性的？ （2）volatile是如何禁止重排序的？ （3）volatile的实现原理？ （4）volatile的缺陷？ 简介 volatile...

    番茄西红柿 评论0 收藏0

  • 死磕 java同步系列之volatile解析

    摘要：前半句是指线程内表现为串行的语义，后半句是指指令重排序现象和工作内存和主内存同步延迟现象。关于内存模型的讲解请参考死磕同步系列之。目前国内市面上的关于内存屏障的讲解基本不会超过这三篇文章，包括相关书籍中的介绍。问题 （1）volatile是如何保证可见性的？ （2）volatile是如何禁止重排序的？ （3）volatile的实现原理？ （4）volatile的缺陷？ 简介 volatile...

    番茄西红柿 评论0 收藏0

发表评论

登陆后可评论

0条评论

Lionad-Morotar

男|高级讲师
我要私信

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<