jdk-sandbox: comparison src/hotspot/share/runtime/thread.cpp

equal deleted inserted replaced

-:8d52b4c6f9d8
+:05aaccf7d558
 // on the SR_lock below provides a much more predictable scale up for
 // the delay. It also provides a simple/direct point to check for any
 // safepoint requests from the VMThread
 {
-MutexLocker ml(SR_lock());
+Thread* t = Thread::current();
+MonitorLocker ml(SR_lock(),
+t->is_Java_thread() ? Mutex::_safepoint_check_flag : Mutex::_no_safepoint_check_flag);
 // wait with safepoint check (if we're a JavaThread - the WatcherThread
 // can also call this)  and increase delay with each retry
-if (Thread::current()->is_Java_thread()) {
+ml.wait(i * delay);
-SR_lock()->wait(i * delay);
-} else {
-SR_lock()->wait_without_safepoint_check(i * delay);
-}
 is_suspended = is_ext_suspend_completed(true /* called_by_wait */,
 delay, bits);
 // It is possible for the external suspend request to be cancelled
 }
 int WatcherThread::sleep() const {
 // The WatcherThread does not participate in the safepoint protocol
 // for the PeriodicTask_lock because it is not a JavaThread.
-MutexLocker ml(PeriodicTask_lock, Mutex::_no_safepoint_check_flag);
+MonitorLocker ml(PeriodicTask_lock, Mutex::_no_safepoint_check_flag);
 if (_should_terminate) {
 // check for termination before we do any housekeeping or wait
 return 0;  // we did not sleep.
 }
 OSThreadWaitState osts(this->osthread(), false /* not Object.wait() */);
 jlong time_before_loop = os::javaTimeNanos();
 while (true) {
-bool timedout = PeriodicTask_lock->wait_without_safepoint_check(remaining);
+bool timedout = ml.wait(remaining);
 jlong now = os::javaTimeNanos();
 if (remaining == 0) {
 // if we didn't have any tasks we could have waited for a long time
 // consider the time_slept zero and reset time_before_loop
 // unpark the WatcherThread so it can see that it should terminate
 watcher->unpark();
 }
 }
-MutexLocker mu(Terminator_lock);
+MonitorLocker mu(Terminator_lock);
 while (watcher_thread() != NULL) {
 // This wait should make safepoint checks, wait without a timeout,
 // and wait as a suspend-equivalent condition.
-Terminator_lock->wait(0, Mutex::_as_suspend_equivalent_flag);
+mu.wait(0, Mutex::_as_suspend_equivalent_flag);
 }
 }
 void WatcherThread::unpark() {
 assert(PeriodicTask_lock->owned_by_self(), "PeriodicTask_lock required");
 assert(_anchor.walkable() ||
 (is_Java_thread() && !((JavaThread*)this)->has_last_Java_frame()),
 "must have walkable stack");
-MutexLocker ml(SR_lock(), Mutex::_no_safepoint_check_flag);
+MonitorLocker ml(SR_lock(), Mutex::_no_safepoint_check_flag);
 assert(!this->is_ext_suspended(),
 "a thread trying to self-suspend should not already be suspended");
 if (this->is_suspend_equivalent()) {
 ret++;
 this->set_ext_suspended();
 // _ext_suspended flag is cleared by java_resume()
 while (is_ext_suspended()) {
-this->SR_lock()->wait_without_safepoint_check();
+ml.wait();
 }
 }
 return ret;
 }
 }
 // Wait for the VM thread to become ready, and VMThread::run to initialize
 // Monitors can have spurious returns, must always check another state flag
 {
-MutexLocker ml(Notify_lock);
+MonitorLocker ml(Notify_lock);
 os::start_thread(vmthread);
 while (vmthread->active_handles() == NULL) {
-Notify_lock->wait();
+ml.wait();
 }
 }
 }
 assert(Universe::is_fully_initialized(), "not initialized");
 #ifdef ASSERT
 _vm_complete = false;
 #endif
 // Wait until we are the last non-daemon thread to execute
-{ MutexLocker nu(Threads_lock);
+{ MonitorLocker nu(Threads_lock);
 while (Threads::number_of_non_daemon_threads() > 1)
 // This wait should make safepoint checks, wait without a timeout,
 // and wait as a suspend-equivalent condition.
-Threads_lock->wait(0, Mutex::_as_suspend_equivalent_flag);
+nu.wait(0, Mutex::_as_suspend_equivalent_flag);
 }
 EventShutdown e;
 if (e.should_commit()) {
 e.set_reason("No remaining non-daemon Java threads");
 // Reclaim the ObjectMonitors from the omInUseList and omFreeList of the moribund thread.
 ObjectSynchronizer::omFlush(p);
 // Extra scope needed for Thread_lock, so we can check
 // that we do not remove thread without safepoint code notice
-{ MutexLocker ml(Threads_lock);
+{ MonitorLocker ml(Threads_lock);
 assert(ThreadsSMRSupport::get_java_thread_list()->includes(p), "p must be present");
 // Maintain fast thread list
 ThreadsSMRSupport::remove_thread(p);
 _number_of_non_daemon_threads--;
 // Only one thread left, do a notify on the Threads_lock so a thread waiting
 // on destroy_vm will wake up.
 if (number_of_non_daemon_threads() == 1) {
-Threads_lock->notify_all();
+ml.notify_all();
 }
 }
 ThreadService::remove_thread(p, is_daemon);
 // Make sure that safepoint code disregard this thread. This is needed since

changeset 54645	05aaccf7d558
parent 54631	3a3e4e473622
child 54647	c0d9bc9b4e1f