125 extern Mutex*   CDSClassFileStream_lock;         // FileMapInfo::open_stream_for_jvmti
 126 #endif
 127 extern Mutex*   DumpTimeTable_lock;              // SystemDictionaryShared::find_or_allocate_info_for
 128 #endif // INCLUDE_CDS
 129 #if INCLUDE_JFR
 130 extern Mutex*   JfrStacktrace_lock;              // used to guard access to the JFR stacktrace table
 131 extern Monitor* JfrMsg_lock;                     // protects JFR messaging
 132 extern Mutex*   JfrBuffer_lock;                  // protects JFR buffer operations
 133 extern Mutex*   JfrStream_lock;                  // protects JFR stream access
 134 extern Monitor* JfrThreadSampler_lock;           // used to suspend/resume JFR thread sampler
 135 #endif
 136 
 137 #ifndef SUPPORTS_NATIVE_CX8
 138 extern Mutex*   UnsafeJlong_lock;                // provides Unsafe atomic updates to jlongs on platforms that don't support cx8
 139 #endif
 140 
 141 extern Mutex*   MetaspaceExpand_lock;            // protects Metaspace virtualspace and chunk expansions
 142 extern Mutex*   ClassLoaderDataGraph_lock;       // protects CLDG list, needed for concurrent unloading
 143 
 144 
 145 extern Monitor* CodeHeapStateAnalytics_lock;     // lock print functions against concurrent analyze functions.
 146                                                  // Only used locally in PrintCodeCacheLayout processing.
 147 
 148 #if INCLUDE_JVMCI
 149 extern Monitor* JVMCI_lock;                      // Monitor to control initialization of JVMCI
 150 #endif
 151 
 152 // A MutexLocker provides mutual exclusion with respect to a given mutex
 153 // for the scope which contains the locker.  The lock is an OS lock, not
 154 // an object lock, and the two do not interoperate.  Do not use Mutex-based
 155 // locks to lock on Java objects, because they will not be respected if a
 156 // that object is locked using the Java locking mechanism.
 157 //
 158 //                NOTE WELL!!
 159 //
 160 // See orderAccess.hpp.  We assume throughout the VM that MutexLocker's
 161 // and friends constructors do a fence, a lock and an acquire *in that
 162 // order*.  And that their destructors do a release and unlock, in *that*
 163 // order.  If their implementations change such that these assumptions
 164 // are violated, a whole lot of code will break.
 165 
 166 // Print all mutexes/monitors that are currently owned by a thread; called
 167 // by fatal error handler.
 168 void print_owned_locks_on_error(outputStream* st);
 169 
 170 char *lock_name(Mutex *mutex);
 171 
 172 // for debugging: check that we're already owning this lock (or are at a safepoint)
 173 #ifdef ASSERT
 174 void assert_locked_or_safepoint(const Monitor * lock);
 175 void assert_locked_or_safepoint_weak(const Monitor * lock);
 176 void assert_lock_strong(const Monitor * lock);
 177 #else
 178 #define assert_locked_or_safepoint(lock)
 179 #define assert_locked_or_safepoint_weak(lock)
 180 #define assert_lock_strong(lock)
 181 #endif
 182 
 183 class MutexLocker: public StackObj {
 184  protected:
 185   Monitor* _mutex;
 186  private:
 187  public:
 188   MutexLocker(Monitor* mutex, Mutex::SafepointCheckFlag flag = Mutex::_safepoint_check_flag) :
 189     _mutex(mutex) {
 190     bool no_safepoint_check = flag == Mutex::_no_safepoint_check_flag;
 191     if (_mutex != NULL) {
 192       assert(_mutex->rank() > Mutex::special || no_safepoint_check,
 193              "Mutexes with rank special or lower should not do safepoint checks");
 194       if (no_safepoint_check) {
 195         _mutex->lock_without_safepoint_check();
 196       } else {
 197         _mutex->lock();
 198       }
 199     }
 200   }
 201 
 202   MutexLocker(Monitor* mutex, Thread* thread, Mutex::SafepointCheckFlag flag = Mutex::_safepoint_check_flag) :
 203     _mutex(mutex) {
 204     bool no_safepoint_check = flag == Mutex::_no_safepoint_check_flag;
 205     if (_mutex != NULL) {
 206       assert(_mutex->rank() > Mutex::special || no_safepoint_check,
 207              "Mutexes with rank special or lower should not do safepoint checks");
 208       if (no_safepoint_check) {
 209         _mutex->lock_without_safepoint_check(thread);
 210       } else {
 211         _mutex->lock(thread);
 212       }
 213     }
 214   }
 215 
 216   ~MutexLocker() {
 217     if (_mutex != NULL) {
 218       assert_lock_strong(_mutex);
 219       _mutex->unlock();
 220     }
 221   }
 222 };
 223 
 224 // A MonitorLocker is like a MutexLocker above, except it allows
 225 // wait/notify as well which are delegated to the underlying Monitor.
 226 // It also disallows NULL.
 227 
 228 class MonitorLocker: public MutexLocker {
 229   Mutex::SafepointCheckFlag _flag;

 230  public:
 231   MonitorLocker(Monitor* monitor, Mutex::SafepointCheckFlag flag = Mutex::_safepoint_check_flag) :
 232     MutexLocker(monitor, flag), _flag(flag) {
 233     // Superclass constructor did locking
 234     assert(_mutex != NULL, "NULL monitor not allowed");
 235   }
 236 
 237   MonitorLocker(Monitor* monitor, Thread* thread, Mutex::SafepointCheckFlag flag = Mutex::_safepoint_check_flag) :
 238     MutexLocker(monitor, thread, flag), _flag(flag)  {
 239     // Superclass constructor did locking
 240     assert(_mutex != NULL, "NULL monitor not allowed");
 241   }
 242 
 243   bool wait(long timeout = 0,
 244             bool as_suspend_equivalent = !Mutex::_as_suspend_equivalent_flag) {
 245     if (_flag == Mutex::_safepoint_check_flag) {
 246       return _mutex->wait(timeout, as_suspend_equivalent);
 247     } else {
 248       return _mutex->wait_without_safepoint_check(timeout);
 249     }
 250     return false;
 251   }
 252 
 253   void notify_all() {
 254     _mutex->notify_all();
 255   }
 256 
 257   void notify() {
 258     _mutex->notify();
 259   }
 260 };
 261 
 262 
 263 // A GCMutexLocker is usually initialized with a mutex that is
 264 // automatically acquired in order to do GC.  The function that
 265 // synchronizes using a GCMutexLocker may be called both during and between
 266 // GC's.  Thus, it must acquire the mutex if GC is not in progress, but not
 267 // if GC is in progress (since the mutex is already held on its behalf.)
 268 
 269 class GCMutexLocker: public StackObj {
 270 private:
 271   Monitor* _mutex;
 272   bool _locked;
 273 public:
 274   GCMutexLocker(Monitor* mutex);
 275   ~GCMutexLocker() { if (_locked) _mutex->unlock(); }
 276 };
 277 
 278 // A MutexUnlocker temporarily exits a previously
 279 // entered mutex for the scope which contains the unlocker.
 280 
 281 class MutexUnlocker: StackObj {
 282  private:
 283   Monitor* _mutex;
 284   bool _no_safepoint_check;
 285 
 286  public:
 287   MutexUnlocker(Monitor* mutex, Mutex::SafepointCheckFlag flag = Mutex::_safepoint_check_flag) :
 288     _mutex(mutex),
 289     _no_safepoint_check(flag) {
 290     _mutex->unlock();
 291   }
 292 
 293   ~MutexUnlocker() {
 294     if (_no_safepoint_check) {
 295       _mutex->lock_without_safepoint_check();
 296     } else {
 297       _mutex->lock();
 298     }
 299   }
 300 };
 301 
 302 #endif // SHARE_RUNTIME_MUTEXLOCKER_HPP

 125 extern Mutex*   CDSClassFileStream_lock;         // FileMapInfo::open_stream_for_jvmti
 126 #endif
 127 extern Mutex*   DumpTimeTable_lock;              // SystemDictionaryShared::find_or_allocate_info_for
 128 #endif // INCLUDE_CDS
 129 #if INCLUDE_JFR
 130 extern Mutex*   JfrStacktrace_lock;              // used to guard access to the JFR stacktrace table
 131 extern Monitor* JfrMsg_lock;                     // protects JFR messaging
 132 extern Mutex*   JfrBuffer_lock;                  // protects JFR buffer operations
 133 extern Mutex*   JfrStream_lock;                  // protects JFR stream access
 134 extern Monitor* JfrThreadSampler_lock;           // used to suspend/resume JFR thread sampler
 135 #endif
 136 
 137 #ifndef SUPPORTS_NATIVE_CX8
 138 extern Mutex*   UnsafeJlong_lock;                // provides Unsafe atomic updates to jlongs on platforms that don't support cx8
 139 #endif
 140 
 141 extern Mutex*   MetaspaceExpand_lock;            // protects Metaspace virtualspace and chunk expansions
 142 extern Mutex*   ClassLoaderDataGraph_lock;       // protects CLDG list, needed for concurrent unloading
 143 
 144 
 145 extern Mutex*   CodeHeapStateAnalytics_lock;     // lock print functions against concurrent analyze functions.
 146                                                  // Only used locally in PrintCodeCacheLayout processing.
 147 
 148 #if INCLUDE_JVMCI
 149 extern Monitor* JVMCI_lock;                      // Monitor to control initialization of JVMCI
 150 #endif
 151 
 152 // A MutexLocker provides mutual exclusion with respect to a given mutex
 153 // for the scope which contains the locker.  The lock is an OS lock, not
 154 // an object lock, and the two do not interoperate.  Do not use Mutex-based
 155 // locks to lock on Java objects, because they will not be respected if a
 156 // that object is locked using the Java locking mechanism.
 157 //
 158 //                NOTE WELL!!
 159 //
 160 // See orderAccess.hpp.  We assume throughout the VM that MutexLocker's
 161 // and friends constructors do a fence, a lock and an acquire *in that
 162 // order*.  And that their destructors do a release and unlock, in *that*
 163 // order.  If their implementations change such that these assumptions
 164 // are violated, a whole lot of code will break.
 165 
 166 // Print all mutexes/monitors that are currently owned by a thread; called
 167 // by fatal error handler.
 168 void print_owned_locks_on_error(outputStream* st);
 169 
 170 char *lock_name(Mutex *mutex);
 171 
 172 // for debugging: check that we're already owning this lock (or are at a safepoint)
 173 #ifdef ASSERT
 174 void assert_locked_or_safepoint(const Mutex* lock);
 175 void assert_locked_or_safepoint_weak(const Mutex* lock);
 176 void assert_lock_strong(const Mutex* lock);
 177 #else
 178 #define assert_locked_or_safepoint(lock)
 179 #define assert_locked_or_safepoint_weak(lock)
 180 #define assert_lock_strong(lock)
 181 #endif
 182 
 183 class MutexLocker: public StackObj {
 184  protected:
 185   Mutex* _mutex;
 186  private:
 187  public:
 188   MutexLocker(Mutex* mutex, Mutex::SafepointCheckFlag flag = Mutex::_safepoint_check_flag) :
 189     _mutex(mutex) {
 190     bool no_safepoint_check = flag == Mutex::_no_safepoint_check_flag;
 191     if (_mutex != NULL) {
 192       assert(_mutex->rank() > Mutex::special || no_safepoint_check,
 193              "Mutexes with rank special or lower should not do safepoint checks");
 194       if (no_safepoint_check) {
 195         _mutex->lock_without_safepoint_check();
 196       } else {
 197         _mutex->lock();
 198       }
 199     }
 200   }
 201 
 202   MutexLocker(Mutex* mutex, Thread* thread, Mutex::SafepointCheckFlag flag = Mutex::_safepoint_check_flag) :
 203     _mutex(mutex) {
 204     bool no_safepoint_check = flag == Mutex::_no_safepoint_check_flag;
 205     if (_mutex != NULL) {
 206       assert(_mutex->rank() > Mutex::special || no_safepoint_check,
 207              "Mutexes with rank special or lower should not do safepoint checks");
 208       if (no_safepoint_check) {
 209         _mutex->lock_without_safepoint_check(thread);
 210       } else {
 211         _mutex->lock(thread);
 212       }
 213     }
 214   }
 215 
 216   ~MutexLocker() {
 217     if (_mutex != NULL) {
 218       assert_lock_strong(_mutex);
 219       _mutex->unlock();
 220     }
 221   }
 222 };
 223 
 224 // A MonitorLocker is like a MutexLocker above, except it allows
 225 // wait/notify as well which are delegated to the underlying Monitor.
 226 // It also disallows NULL.
 227 
 228 class MonitorLocker: public MutexLocker {
 229   Mutex::SafepointCheckFlag _flag;
 230   Monitor* _monitor;
 231  public:
 232   MonitorLocker(Monitor* monitor, Mutex::SafepointCheckFlag flag = Mutex::_safepoint_check_flag) :
 233     MutexLocker(monitor, flag), _flag(flag), _monitor(monitor) {
 234     // Superclass constructor did locking
 235     assert(_monitor != NULL, "NULL monitor not allowed");
 236   }
 237 
 238   MonitorLocker(Monitor* monitor, Thread* thread, Mutex::SafepointCheckFlag flag = Mutex::_safepoint_check_flag) :
 239     MutexLocker(monitor, thread, flag), _flag(flag), _monitor(monitor)  {
 240     // Superclass constructor did locking
 241     assert(_monitor != NULL, "NULL monitor not allowed");
 242   }
 243 
 244   bool wait(long timeout = 0,
 245             bool as_suspend_equivalent = !Mutex::_as_suspend_equivalent_flag) {
 246     if (_flag == Mutex::_safepoint_check_flag) {
 247       return _monitor->wait(timeout, as_suspend_equivalent);
 248     } else {
 249       return _monitor->wait_without_safepoint_check(timeout);
 250     }
 251     return false;
 252   }
 253 
 254   void notify_all() {
 255     _monitor->notify_all();
 256   }
 257 
 258   void notify() {
 259     _monitor->notify();
 260   }
 261 };
 262 
 263 
 264 // A GCMutexLocker is usually initialized with a mutex that is
 265 // automatically acquired in order to do GC.  The function that
 266 // synchronizes using a GCMutexLocker may be called both during and between
 267 // GC's.  Thus, it must acquire the mutex if GC is not in progress, but not
 268 // if GC is in progress (since the mutex is already held on its behalf.)
 269 
 270 class GCMutexLocker: public StackObj {
 271 private:
 272   Mutex* _mutex;
 273   bool _locked;
 274 public:
 275   GCMutexLocker(Mutex* mutex);
 276   ~GCMutexLocker() { if (_locked) _mutex->unlock(); }
 277 };
 278 
 279 // A MutexUnlocker temporarily exits a previously
 280 // entered mutex for the scope which contains the unlocker.
 281 
 282 class MutexUnlocker: StackObj {
 283  private:
 284   Mutex* _mutex;
 285   bool _no_safepoint_check;
 286 
 287  public:
 288   MutexUnlocker(Mutex* mutex, Mutex::SafepointCheckFlag flag = Mutex::_safepoint_check_flag) :
 289     _mutex(mutex),
 290     _no_safepoint_check(flag) {
 291     _mutex->unlock();
 292   }
 293 
 294   ~MutexUnlocker() {
 295     if (_no_safepoint_check) {
 296       _mutex->lock_without_safepoint_check();
 297     } else {
 298       _mutex->lock();
 299     }
 300   }
 301 };
 302 
 303 #endif // SHARE_RUNTIME_MUTEXLOCKER_HPP