将 volatile 关键字与可变对象一起使用

Question

在Java中，我知道易失性关键字提供了变量的可见性。问题是，如果变量是对可变对象的引用，那么 volatile 是否也提供该对象内部成员的可见性？

在下面的示例中，如果多个线程正在访问 易失性可变 m 并更改值，它是否可以正常工作？

例子

class Mutable {
    private int value;
    public int get()
    {
        return a;
    }
    public int set(int value)
    {
        this.value = value;
    }
}

class Test {
    public volatile Mutable m;
}

Answer 1

在您的示例中，volatile 关键字仅保证任何线程对“m”写入的最后一个引用对于随后读取“m”的任何线程都可见。

它不保证有关您的 get() 的任何信息。

因此，使用以下序列：

Thread-1: get()     returns 2
Thread-2: set(3)
Thread-1: get()    

返回 2 而不是 3 是完全合法的。volatile 不会对此进行任何更改。

但是，如果您将 Mutable 类更改为：

class Mutable {
    private volatile int value;
    public int get()
    {
        return a;
    }
    public int set(int value)
    {
        this.value = value;
    }
}

那么就保证 Thread-1 中的第二个 get() 将返回 3。

但请注意 volatile< /code> 通常不是最好的同步方法。

在简单的获取/设置示例中（我知道这只是一个示例），像 AtomicInteger 这样的类，使用适当的同步并实际提供有用的方法会更好。

Answer 2

易失性仅提供对如此声明的对象的引用的保证。该实例的成员不会同步。

根据 维基百科，您有：

• （在 Java 的所有版本中）读取和读取都有一个全局排序
  写入易失性变量。这
  意味着每个访问 a 的线程
  易失性字段将读取其当前值
  继续之前的值，而不是
  （可能）使用缓存值。
  （但是，不能保证
  挥发性的相对顺序
  与常规读取一起读取和写入
  并写道，这意味着它是
  通常不是有用的线程
  构造。）
• （在 Java 5 或更高版本中）易失性读取和写入建立发生之前
  关系，就像获取和
  释放互斥锁。

所以基本上你所拥有的是，通过声明字段易失性，与其交互创建一个“同步点”，之后任何更改都将在其他线程中可见。但此后，使用 get() 或 set() 是不同步的。 Java 规范有更全面的解释。

Answer 3

使用易失性而不是完全同步值本质上是一种优化。与同步访问相比，优化来自于为易失性值提供的较弱的保证。过早的优化是万恶之源；在这种情况下，邪恶可能很难追踪，因为它会以竞争条件等形式出现。因此，如果您需要询问，您可能不应该使用它。

Answer 4

易失性不“提供可见性”。它的唯一作用是防止处理器缓存变量，从而提供并发读取和写入的先发生关系。它不会影响对象的成员，也不提供任何同步同步锁定。

由于您没有告诉我们您的代码的“正确”行为是什么，因此无法回答该问题。

Answer 5

这是对 volatile 的一些细节的旁注解释。写在这里是因为评论太多了。我想举一些例子来说明 volatile 如何影响可见性，以及它在 jdk 1.5 中如何变化。

给出以下示例代码：

public class MyClass
{
  private int _n;
  private volatile int _volN;

  public void setN(int i) {
    _n = i;
  }
  public void setVolN(int i) {
    _volN = i;
  }
  public int getN() { 
    return _n; 
  }
  public int getVolN() { 
    return _volN; 
  }

  public static void main() {
    final MyClass mc = new MyClass();

    Thread t1 = new Thread() {
      public void run() {
        mc.setN(5);
        mc.setVolN(5);
      }
    };

    Thread t2 = new Thread() {
      public void run() {
        int volN = mc.getVolN();
        int n = mc.getN();
        System.out.println("Read: " + volN + ", " + n);
      }
    };

    t1.start();
    t2.start();
  }
}

该测试代码的行为在 jdk1.5+ 中定义良好，但在 jdk1.5 之前未定义良好。

在jdk1.5之前的世界中，易失性访问和非易失性访问之间没有定义的关系。因此，该程序的输出可能是：

1. Read: 0, 0
2. Read: 0, 5
3. Read: 5, 0
4. Read: 5, 5

在 jdk1.5+ 的世界中，易失性的语义发生了变化，因此易失性访问会影响非易失性访问。 - 易失性访问的方式与同步完全相同。因此，在 jdk1.5+ 世界中，只有某些输出是可能的：

1. 读取：0, 0
2. 读取：0, 5
3. 读取：5, 0 <- 不可能
4. 读取：5, 5

输出 3。这是不可能的，因为从易失性 _volN 读取“5”会在 2 个线程之间建立同步点，这意味着在分配给 _volN 之前从 t1 执行的所有操作必须对 t2 可见。

进一步阅读：

• 修复 java 内存模型，第 1 部分
• 修复 java 内存模型，第 2 部分