src/hotspot/share/runtime/mutex.cpp

rev 56448 : imported patch monitor_contended

@@ -68,31 +68,27 @@
          "This lock should %s have a safepoint check for Java threads: %s",
          _safepoint_check_required ? "always" : "never", name());
 }
 #endif // ASSERT
 
-void Mutex::lock(Thread* self) {
-  check_safepoint_state(self);
-
-  assert(_owner != self, "invariant");
-
-  Mutex* in_flight_mutex = NULL;
+void Mutex::lock_contended(Thread* self) {
+  // The lock is contended
+  Mutex *in_flight_mutex = NULL;
   DEBUG_ONLY(int retry_cnt = 0;)
   bool is_active_Java_thread = self->is_active_Java_thread();
-  while (!_lock.try_lock()) {
-    // The lock is contended
-
-  #ifdef ASSERT
+  do {
+#ifdef ASSERT
     if (retry_cnt++ > 3) {
       log_trace(vmmutex)("JavaThread " INTPTR_FORMAT " on %d attempt trying to acquire vmmutex %s", p2i(self), retry_cnt, _name);
     }
-  #endif // ASSERT
+#endif // ASSERT
 
     // Is it a JavaThread participating in the safepoint protocol.
     if (is_active_Java_thread) {
       assert(rank() > Mutex::special, "Potential deadlock with special or lesser rank mutex");
-      { ThreadBlockInVMWithDeadlockCheck tbivmdc((JavaThread *) self, &in_flight_mutex);
+      {
+        ThreadBlockInVMWithDeadlockCheck tbivmdc((JavaThread *) self, &in_flight_mutex);
         in_flight_mutex = this;  // save for ~ThreadBlockInVMWithDeadlockCheck
         _lock.lock();
       }
       if (in_flight_mutex != NULL) {
         // Not unlocked by ~ThreadBlockInVMWithDeadlockCheck

@@ -100,18 +96,29 @@
       }
     } else {
       _lock.lock();
       break;
     }
+  } while (!_lock.try_lock());
+}
+
+void Mutex::lock(Thread* self) {
+  check_safepoint_state(self);
+
+  assert(_owner != self, "invariant");
+
+  if (!_lock.try_lock()) {
+    // The lock is contended, use contended slow-path function to lock
+    lock_contended(self);
   }
 
   assert_owner(NULL);
   set_owner(self);
 }
 
 void Mutex::lock() {
-  this->lock(Thread::current());
+  lock(Thread::current());
 }
 
 // Lock without safepoint check - a degenerate variant of lock() for use by
 // JavaThreads when it is known to be safe to not check for a safepoint when
 // acquiring this lock. If the thread blocks acquiring the lock it is not