--- old/src/hotspot/share/runtime/objectMonitor.inline.hpp	2019-12-17 15:48:14.000000000 -0500
+++ new/src/hotspot/share/runtime/objectMonitor.inline.hpp	2019-12-17 15:48:14.000000000 -0500
@@ -25,6 +25,7 @@
 #ifndef SHARE_RUNTIME_OBJECTMONITOR_INLINE_HPP
 #define SHARE_RUNTIME_OBJECTMONITOR_INLINE_HPP
 
+#include "logging/log.hpp"
 #include "runtime/atomic.hpp"
 
 inline intptr_t ObjectMonitor::is_entered(TRAPS) const {
@@ -84,8 +85,65 @@
   return _contentions;
 }
 
-inline void ObjectMonitor::set_owner(void* owner) {
-  _owner = owner;
+// Clear _owner field; current value must match old_value.
+// If needs_fence is true, we issue a fence() after the release_store().
+// Otherwise, a storeload() is good enough. See the callers for more info.
+inline void ObjectMonitor::release_clear_owner_with_barrier(void* old_value,
+                                                            bool needs_fence) {
+  void* prev = _owner;
+  assert(prev == old_value, "unexpected prev owner=" INTPTR_FORMAT
+         ", expected=" INTPTR_FORMAT, p2i(prev), p2i(old_value));
+  Atomic::release_store(&_owner, (void*)NULL);
+  if (needs_fence) {
+    OrderAccess::fence();
+  } else {
+    OrderAccess::storeload();
+  }
+  log_trace(monitorinflation, owner)("release_clear_owner_with_barrier(): mid="
+                                     INTPTR_FORMAT ", prev=" INTPTR_FORMAT
+                                     ", needs_fence=%d", p2i(this), p2i(prev),
+                                     needs_fence);
+}
+
+// Simply set _owner field to new_value; current value must match old_value.
+// (Simple means no memory sync needed.)
+inline void ObjectMonitor::simply_set_owner_from(void* old_value, void* new_value) {
+  void* prev = _owner;
+  assert(prev == old_value, "unexpected prev owner=" INTPTR_FORMAT
+         ", expected=" INTPTR_FORMAT, p2i(prev), p2i(old_value));
+  _owner = new_value;
+  log_trace(monitorinflation, owner)("simply_set_owner_from(): mid="
+                                     INTPTR_FORMAT ", prev=" INTPTR_FORMAT
+                                     ", new=" INTPTR_FORMAT, p2i(this),
+                                     p2i(prev), p2i(new_value));
+}
+
+// Simply set _owner field to self; current value must match basic_lock_p.
+inline void ObjectMonitor::simply_set_owner_from_BasicLock(void* basic_lock_p, Thread* self) {
+  void* prev = _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;
+  log_trace(monitorinflation, owner)("simply_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));
+}
+
+// Try to set _owner field to new_value if the current value matches
+// old_value. Otherwise, does not change the _owner field.
+inline void* ObjectMonitor::try_set_owner_from(void* old_value, void* new_value) {
+  void* prev = Atomic::cmpxchg(&_owner, old_value, new_value);
+  if (prev == old_value) {
+    log_trace(monitorinflation, owner)("try_set_owner_from(): mid="
+                                       INTPTR_FORMAT ", prev=" INTPTR_FORMAT
+                                       ", new=" INTPTR_FORMAT, p2i(this),
+                                       p2i(prev), p2i(new_value));
+  }
+  return prev;
 }
 
 #endif // SHARE_RUNTIME_OBJECTMONITOR_INLINE_HPP