--- old/src/hotspot/share/runtime/objectMonitor.cpp	2020-01-28 14:37:00.000000000 -0500
+++ new/src/hotspot/share/runtime/objectMonitor.cpp	2020-01-28 14:37:00.000000000 -0500
@@ -860,9 +860,9 @@
 // of such futile wakups is low.
 
 void ObjectMonitor::exit(bool not_suspended, TRAPS) {
-  Thread * const Self = THREAD;
-  if (THREAD != _owner) {
-    void* cur = _owner;
+  Thread* const Self = THREAD;
+  void* cur = Atomic::load(&_owner);
+  if (THREAD != cur) {
     if (THREAD->is_lock_owned((address)cur)) {
       assert(_recursions == 0, "invariant");
       set_owner_from_BasicLock(cur, Self);  // Convert from BasicLock* to Thread*.
@@ -1120,8 +1120,8 @@
 
   assert(InitDone, "Unexpectedly not initialized");
 
-  if (THREAD != _owner) {
-    void* cur = _owner;
+  void* cur = Atomic::load(&_owner);
+  if (THREAD != cur) {
     if (THREAD->is_lock_owned((address)cur)) {
       assert(_recursions == 0, "internal state error");
       set_owner_from_BasicLock(cur, Self);  // Convert from BasicLock* to Thread*.
@@ -1169,10 +1169,10 @@
 // (IMSE). If there is a pending exception and the specified thread
 // is not the owner, that exception will be replaced by the IMSE.
 bool ObjectMonitor::check_owner(Thread* THREAD) {
-  if (_owner == THREAD) {
+  void* cur = Atomic::load(&_owner);
+  if (cur == THREAD) {
     return true;
   }
-  void* cur = _owner;
   if (THREAD->is_lock_owned((address)cur)) {
     set_owner_from_BasicLock(cur, THREAD);  // Convert from BasicLock* to Thread*.
     _recursions = 0;
--- old/src/hotspot/share/runtime/objectMonitor.hpp	2020-01-28 14:37:01.000000000 -0500
+++ new/src/hotspot/share/runtime/objectMonitor.hpp	2020-01-28 14:37:01.000000000 -0500
@@ -239,7 +239,9 @@
   // Simply set _owner field to self; current value must match basic_lock_p.
   void      set_owner_from_BasicLock(void* basic_lock_p, Thread* self);
   // Try to set _owner field to new_value if the current value matches
-  // old_value. Otherwise, does not change the _owner field.
+  // old_value. Otherwise, does not change the _owner field. Returns
+  // the prior value of the _owner field. try_set_owner_from() provides:
+  //   <fence> compare-and-exchange <membar StoreLoad|StoreStore>
   void*     try_set_owner_from(void* old_value, void* new_value);
 
   jint      waiters() const;
--- old/src/hotspot/share/runtime/objectMonitor.inline.hpp	2020-01-28 14:37:02.000000000 -0500
+++ new/src/hotspot/share/runtime/objectMonitor.inline.hpp	2020-01-28 14:37:02.000000000 -0500
@@ -87,41 +87,40 @@
 
 // Clear _owner field; current value must match old_value.
 inline void ObjectMonitor::release_clear_owner(void* old_value) {
-  void* prev = _owner;
+  DEBUG_ONLY(void* prev = Atomic::load(&_owner);)
   assert(prev == old_value, "unexpected prev owner=" INTPTR_FORMAT
          ", expected=" INTPTR_FORMAT, p2i(prev), p2i(old_value));
   Atomic::release_store(&_owner, (void*)NULL);
   log_trace(monitorinflation, owner)("release_clear_owner(): mid="
-                                     INTPTR_FORMAT ", prev=" INTPTR_FORMAT,
-                                     p2i(this), p2i(prev));
+                                     INTPTR_FORMAT ", old_value=" INTPTR_FORMAT,
+                                     p2i(this), p2i(old_value));
 }
 
 // Simply set _owner field to new_value; current value must match old_value.
 // (Simple means no memory sync needed.)
 inline void ObjectMonitor::set_owner_from(void* old_value, void* new_value) {
-  void* prev = _owner;
+  DEBUG_ONLY(void* prev = Atomic::load(&_owner);)
   assert(prev == old_value, "unexpected prev owner=" INTPTR_FORMAT
          ", expected=" INTPTR_FORMAT, p2i(prev), p2i(old_value));
-  _owner = new_value;
+  Atomic::store(&_owner, new_value);
   log_trace(monitorinflation, owner)("set_owner_from(): mid="
-                                     INTPTR_FORMAT ", prev=" INTPTR_FORMAT
-                                     ", new=" INTPTR_FORMAT, p2i(this),
-                                     p2i(prev), p2i(new_value));
+                                     INTPTR_FORMAT ", old_value=" INTPTR_FORMAT
+                                     ", new_value=" INTPTR_FORMAT, p2i(this),
+                                     p2i(old_value), p2i(new_value));
 }
 
 // Simply set _owner field to self; current value must match basic_lock_p.
 inline void ObjectMonitor::set_owner_from_BasicLock(void* basic_lock_p, Thread* self) {
-  void* prev = _owner;
+  DEBUG_ONLY(void* prev = Atomic::load(&_owner);)
   assert(prev == basic_lock_p, "unexpected prev owner=" INTPTR_FORMAT
          ", expected=" INTPTR_FORMAT, p2i(prev), p2i(basic_lock_p));
   // Non-null owner field to non-null owner field is safe without
   // cmpxchg() as long as all readers can tolerate either flavor.
-  _owner = self;
+  Atomic::store(&_owner, self);
   log_trace(monitorinflation, owner)("set_owner_from_BasicLock(): mid="
-                                     INTPTR_FORMAT ", prev=" INTPTR_FORMAT
-                                     ", new=" INTPTR_FORMAT ", basic_lock_p="
-                                     INTPTR_FORMAT, p2i(this), p2i(prev),
-                                     p2i(self), p2i(basic_lock_p));
+                                     INTPTR_FORMAT ", basic_lock_p="
+                                     INTPTR_FORMAT ", new_value=" INTPTR_FORMAT,
+                                     p2i(this), p2i(basic_lock_p), p2i(self));
 }
 
 // Try to set _owner field to new_value if the current value matches