多个字段：volatile还是AtomicReference？(multiple fields: volatile or AtomicReference?)

 我必须将线程之间的访问同步到共享对象，共享对象的状态由多个字段组成。 说： 
 
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>中检索的，因此注释同意要采用不可变方法或通过同步共享所有更新来实现。 但是，为了完整性，很高兴知道上面使用ConcurrentHashMap<Id,AtomicReference<Shared>>的解决方案是可行的还是错误的还是多余的。 谁能解释一下？ 谢谢！ 

I have to synchronize access between threads to a shared object, whose state consists of several fields. Say:
 
class Shared{
String a; Integer b;
//constructor, getters and setters
....
}
 
I have possibly many threads reading this objects, doing
 
//readers
shared.getA();
shared.getB();
 
and only one thread that will write at a certain point:
 
//writer
shared.setA("state");
shared.setB(1);
 
now my question is how to ensure that reading threads won't find the shared object in an inconsistent state.
 
I read many answers saying that for consistency between threads volatile is the solution,but I'm not sure how it works on multiple fields. E.g., is that enough?
 
volatile  String a; volatile Integer b;
 
Another solution would be to make the shared object immutable and use AtomicReference, E.g., 
 
AtomicReference<Shared> shared = ....
 
and then the writer will just swap the reference:
 
Shared prev = shared.get(); 
Shared newValue = new Shared("state",1);
while (!shared.compareAndSet(prev, newValue)) 
 
Is that approach correct? thanks!
 
Update In my setting the Shared objects are retrieved from a ConcurrentHashMap<Id,Shared>, so the comments agree that the way to go is either using the immutable approach or via synchronizing the updates on shared all together. However, for completeness would be nice to know whether the solution above with the ConcurrentHashMap<Id,AtomicReference<Shared>> is viable or wrong or just superfluous. Anyone can explain? thanks!

原文：https://stackoverflow.com/questions/21283293