多个字段：volatile 还是 AtomicReference？

Question

我必须将线程之间的访问同步到一个共享对象，该对象的状态由几个字段组成。说：

class Shared{
String a; Integer b;
//constructor, getters and setters
....
}

我可能有很多线程正在读取这个对象，正在做

//readers
shared.getA();
shared.getB();

只有一个线程会在某个时间点写入：

//writer
shared.setA("state");
shared.setB(1);

现在我的问题是如何确保读取线程不会发现处于不一致状态的共享对象。

我读了很多答案，说为了线程之间的一致性volatile 是解决方案，但我不确定它如何在多个字段上工作。例如，这就够了吗？

volatile  String a; volatile Integer b;

另一种解决方案是使共享对象不可变并使用 AtomicReference，例如，

AtomicReference<Shared> shared = ....

然后作者将交换引用：

Shared prev = shared.get(); 
Shared newValue = new Shared("state",1);
while (!shared.compareAndSet(prev, newValue)) 

这种方法正确吗？谢谢！

更新在我的设置中，共享对象是从ConcurrentHashMap<Id,Shared> 检索的，因此 cmets 同意要走的路是使用不可变方法或通过将共享上的更新同步在一起。但是，为了完整起见，很高兴知道上面使用 ConcurrentHashMap<Id,AtomicReference<Shared>> 的解决方案是可行的、错误的还是多余的。谁能解释一下？谢谢！

Answer 1

正如@Mikhail 在他的回答中所说，使Shared 不可变并替换整个对象是一种不错的方法。如果出于某种原因您不想或“不能”使用该方法，您只需确保 Shared 上的所有字段都受到同一个锁的保护，并且它们只能一起修改（参见 @ 987654323@ 在我的例子中），那么就不可能看到它们处于不一致的状态。

例如

class Shared {
  private String a;
  private String b;
  public synchronized String getA() {
    return a;
  }
  public synchronized String getB() {
    return b;
  }
  public synchronized void update(String a, String b) {
    this.a = a;
    this.b = b;
  } 
}

Answer 2

将字段标记为 volatile 或使方法同步并不能确保原子性。

Writer 应该注意原子性。

Writer 应该调用同步块内的所有设置器（应该以原子方式更新）。 同步（共享）{ shared.setA() shared.setB() ... }

为此，共享对象中的所有 getter 也应该同步。

Answer 3

如果您需要将 A 和 B 写在一起以保持它们一致，例如它们是名称和社会安全号码，一种方法是在任何地方使用synchronized 并编写一个单一组合 setter。

public synchronized void setNameAndSSN(String name, int ssn) {
   // do validation checking etc...
   this.name = name;
   this.ssn = ssn;
}

public synchronized String getName() { return this.name; }

public synchronized int getSSN() { return this.ssn; }

否则，读者可以“看到”具有新名称但具有旧 SSN 的对象。

不可变的方法也很有意义。

Answer 4

首先你应该让Shared不可变：

class Shared{
   private final String a; 
   private final int b;
   //constructor, getters and NO setters
}

如果你只有一个 writer，你可以安全地使用 volatile，在 AtomicRefference 中就不需要了。在更新信息时，不应修改旧对象，而应创建新对象并将其分配给 volatile 引用。