Java 中的内在锁定提供的内存可见性保证？

Question

我需要弄清楚在 Java 中使用内在锁提供了哪些内存可见性保证。

例如，假设我有一个将字符串映射到 Person 对象的 HashMap 对象，如下所示：

HashMap<String,Person> m = new HashMap<String, Person>();

假设我们在同一个 class 中有一个同步方法，如下所示：

public synchronized void addToMap(String name, Person p){
   m.put(name, p);
}

同样 class 还有另一个同步方法叫做 get，像这样：

public synchronized Person get(String name){
   return m.get(name);
}

所以我有两个问题。

1

现在假设线程 A 获取锁并执行 addToMap 方法。然后退出该方法并释放锁。

然后线程 B 在锁定方法之外出现，并更改引用 p 引用的 Person 对象的状态。

那么，当线程 C 获取与线程 A 相同的锁并执行 get() 方法时，线程 C 是否保证能够检索到处于其最新状态的 Person 对象？即在线程 B 更改它之后。

现在这个例子是高度人为的，如果我使用多线程映射那么我知道我应该使用 ConcurrentHashMap 等，这个例子只是用来更好地解释我对可见性保证的困惑。

我知道，当一个线程获取锁时，可以保证看到前一个持有该锁的线程对对象状态所做的任何更改，所以我的想法是否正确，因为线程 B 的 activity 是在没有获得锁的情况下执行的，那么不能保证线程 C 会看到更改？

2

现在，如果我对问题 1 的假设是正确的，那么假设线程 B 确实更改了同步方法中引用 p 引用的 Person 对象的状态，所以它已经获得了锁，那么 C 是否可以保证看到 B 所做的更改？我在这里的初始假设是保证 C 可以看到 B 所做的更改，但是当我想到时，我不确定实际更改是否实际上是对 Person 对象 p 所指的更改 HashMap 的状态（它是锁定对象状态的一部分），因为它不是像添加或删除映射这样的结构修改。

我知道内部锁定提供可见性和原子性保证，而易失性变量仅保证可见性，但我的困惑在于这些保证如何与实际对象相关（例如映射中的实际对象就像 Person 对象 p 所指），而不仅仅是对象引用。

如果能帮助解决这个问题，我们将不胜感激。

Answer 1

I know that when a Thread acquires a lock, it is guaranteed to see any changes that were made to the state of the object from the previous Thread who held that lock, so am I correct in thinking that because Thread B's activity was performed without obtaining the lock, then it is not guaranteed that Thread C will see the changes?

是的。基本上，您如何获得该对象并不重要（在本例中是通过存储在地图中的人员参考）。

无论线程发生什么变化，因为它没有持有锁，所以它不是 happens-before 关系的一部分，因此不能保证后续读取看到更新。

Now if my assumption for Question 1 is correct, then lets say Thread B did actually change the state of the Person object that the reference p refers to inside a synchronized method , so it has acquired the lock, then is C guaranteed to see the change that B made?

如果线程 B 确实持有锁，并且该锁后来被线程 C 获取，则线程 C 将看到线程 B 所做的更改，无论更改是否在映射内等等。

但是，重要的是要记住，仅仅因为您引入了锁并不意味着您没有数据竞争。如果不进一步同步，则无法保证线程 B 实际上会在线程 C 之前获取锁。

希望我正确理解了你的问题，我希望我的回答很清楚。否则请告诉我。

Answer 2

afaict，在您提供的示例中，第一个锁仅在地图上（即它仅影响该地图中给定 Person 的 presence/absence），而第二个锁在 Person 实例上。如果在将 Person 添加到列表时 Person 的某些字段发生更改，则隐式同步不应相互影响，因此它们不会更改行为，也不会以任何方式影响 Person 实例的潜在客户（访问者） .

Answer 3

1) 正确。

2) 正确，假设线程 B:

更改了持有 SAME 锁的 p，或者
在修改后调用了addToMap方法，在这种情况下，线程B是否在同步块内部或外部进行更改并不重要。

但是，还有一个潜在的问题，那就是m HashMap本身的可见性：

m = new HashMap<String, Person>();

此代码未同步，这意味着 m 仅对创建包含 m 的对象的线程可见。其他线程可能会看到地图的空或不一致状态。解决方案是将 m 声明为 volatile 或 final（这就是为什么大多数不可变对象必须将其字段声明为 final 的原因，这不仅仅是一种约定）。

可以找到 happens-before 关系的完整描述 here。

Java 中的内在锁定提供的内存可见性保证？

Memory visibility guarantees provided by intrinsic locking in Java?

java

multithreading

synchronization

locking

volatile