((cite: hotspot/src/share/vm/runtime/objectMonitor.hpp))
    // WARNING:
    //   This is a very sensitive and fragile class. DO NOT make any
    // change unless you are fully aware of the underlying semantics.

    //   This class can not inherit from any other class, because I have
    // to let the displaced header be the very first word. Otherwise I
    // have to let markOop include this file, which would export the
    // monitor data structure to everywhere.
    //
    // The ObjectMonitor class is used to implement JavaMonitors which have
    // transformed from the lightweight structure of the thread stack to a
    // heavy weight lock due to contention

    // It is also used as RawMonitor by the JVMTI

    ((cite: hotspot/src/share/vm/runtime/objectMonitor.hpp))
    class ObjectMonitor {

    ((cite: hotspot/src/share/vm/runtime/synchronizer.cpp))
    // -----------------------------------------------------------------------------
    // ObjectMonitor Lifecycle
    // -----------------------
    // Inflation unlinks monitors from the global gFreeList and
    // associates them with objects.  Deflation -- which occurs at
    // STW-time -- disassociates idle monitors from objects.  Such
    // scavenged monitors are returned to the gFreeList.
    //
    // The global list is protected by ListLock.  All the critical sections
    // are short and operate in constant-time.
    //
    // ObjectMonitors reside in type-stable memory (TSM) and are immortal.
    //
    // Lifecycle:
    // --   unassigned and on the global free list
    // --   unassigned and on a thread's private omFreeList
    // --   assigned to an object.  The object is inflated and the mark refers
    //      to the objectmonitor.
    //

    ((cite: hotspot/src/share/vm/runtime/objectMonitor.cpp))
             // Normally the exiting thread is responsible for ensuring succession,
             // but if other successors are ready or other entering threads are spinning
             // then this thread can simply store NULL into _owner and exit without
             // waking a successor.  The existence of spinners or ready successors
             // guarantees proper succession (liveness).  Responsibility passes to the
             // ready or running successors.  The exiting thread delegates the duty.
             // More precisely, if a successor already exists this thread is absolved
             // of the responsibility of waking (unparking) one.
             //
             // The _succ variable is critical to reducing futile wakeup frequency.
             // _succ identifies the "heir presumptive" thread that has been made
             // ready (unparked) but that has not yet run.  We need only one such
             // successor thread to guarantee progress.
             // See http://www.usenix.org/events/jvm01/full_papers/dice/dice.pdf
             // section 3.3 "Futile Wakeup Throttling" for details.
             //
             // Note that spinners in Enter() also set _succ non-null.
             // In the current implementation spinners opportunistically set
             // _succ so that exiting threads might avoid waking a successor.
             // Another less appealing alternative would be for the exiting thread
             // to drop the lock and then spin briefly to see if a spinner managed
             // to acquire the lock.  If so, the exiting thread could exit
             // immediately without waking a successor, otherwise the exiting
             // thread would need to dequeue and wake a successor.
             // (Note that we'd need to make the post-drop spin short, but no
             // shorter than the worst-case round-trip cache-line migration time.
             // The dropped lock needs to become visible to the spinner, and then
             // the acquisition of the lock by the spinner must become visible to
             // the exiting thread).
             //

    ((cite: hotspot/src/share/vm/runtime/objectMonitor.hpp))
      // WARNING: this must be the very first word of ObjectMonitor
      // This means this class can't use any virtual member functions.
      // TODO-FIXME: assert that offsetof(_header) is 0 or get rid of the
      // implicit 0 offset in emitted code.

      volatile markOop   _header;       // displaced object header word - mark
      void*     volatile _object;       // backward object pointer - strong root

      double SharingPad [1] ;           // temp to reduce false sharing

      // All the following fields must be machine word aligned
      // The VM assumes write ordering wrt these fields, which can be
      // read from other threads.

    ((cite: hotspot/src/share/vm/runtime/objectMonitor.hpp))
      void *  volatile _owner;          // pointer to owning thread OR BasicLock
      volatile intptr_t  _recursions;   // recursion count, 0 for first entry

    ((cite: hotspot/src/share/vm/runtime/objectMonitor.hpp))
      int OwnerIsThread ;               // _owner is (Thread *) vs SP/BasicLock
      ObjectWaiter * volatile _cxq ;    // LL of recently-arrived threads blocked on entry.
                                        // The list is actually composed of WaitNodes, acting
                                        // as proxies for Threads.

    ((cite: hotspot/src/share/vm/runtime/objectMonitor.hpp))
      ObjectWaiter * volatile _EntryList ;     // Threads blocked on entry or reentry.

    ((cite: hotspot/src/share/vm/runtime/objectMonitor.hpp))
      Thread * volatile _succ ;          // Heir presumptive thread - used for futile wakeup throttling
      Thread * volatile _Responsible ;
      int _PromptDrain ;                // rqst to drain cxq into EntryList ASAP

      volatile int _Spinner ;           // for exit->spinner handoff optimization
      volatile int _SpinFreq ;          // Spin 1-out-of-N attempts: success rate
      volatile int _SpinClock ;
      volatile int _SpinDuration ;
      volatile intptr_t _SpinState ;    // MCS/CLH list of spinners

      // TODO-FIXME: _count, _waiters and _recursions should be of
      // type int, or int32_t but not intptr_t.  There's no reason
      // to use 64-bit fields for these variables on a 64-bit JVM.

      volatile intptr_t  _count;        // reference count to prevent reclaimation/deflation
                                        // at stop-the-world time.  See deflate_idle_monitors().
                                        // _count is approximately |_WaitSet| + |_EntryList|

    ((cite: hotspot/src/share/vm/runtime/objectMonitor.hpp))
      volatile intptr_t  _waiters;      // number of waiting threads

    ((cite: hotspot/src/share/vm/runtime/objectMonitor.hpp))
      ObjectWaiter * volatile _WaitSet; // LL of threads wait()ing on the monitor

    ((cite: hotspot/src/share/vm/runtime/objectMonitor.hpp))
      volatile int _WaitSetLock;        // protects Wait Queue - simple spinlock

    ((cite: hotspot/src/share/vm/runtime/objectMonitor.hpp))
      int _QMix ;                       // Mixed prepend queue discipline
      ObjectMonitor * FreeNext ;        // Free list linkage
      intptr_t StatA, StatsB ;

    ((cite: hotspot/src/share/vm/runtime/objectMonitor.hpp))
      static PerfCounter * _sync_ContendedLockAttempts ;
      static PerfCounter * _sync_FutileWakeups ;
      static PerfCounter * _sync_Parks ;
      static PerfCounter * _sync_EmptyNotifications ;
      static PerfCounter * _sync_Notifications ;
      static PerfCounter * _sync_SlowEnter ;
      static PerfCounter * _sync_SlowExit ;
      static PerfCounter * _sync_SlowNotify ;
      static PerfCounter * _sync_SlowNotifyAll ;
      static PerfCounter * _sync_FailedSpins ;
      static PerfCounter * _sync_SuccessfulSpins ;
      static PerfCounter * _sync_PrivateA ;
      static PerfCounter * _sync_PrivateB ;
      static PerfCounter * _sync_MonInCirculation ;
      static PerfCounter * _sync_MonScavenged ;
      static PerfCounter * _sync_Inflations ;
      static PerfCounter * _sync_Deflations ;
      static PerfLongVariable * _sync_MonExtant ;

    ((cite: hotspot/src/share/vm/runtime/objectMonitor.hpp))
    // ObjectWaiter serves as a "proxy" or surrogate thread.
    // TODO-FIXME: Eliminate ObjectWaiter and use the thread-specific
    // ParkEvent instead.  Beware, however, that the JVMTI code
    // knows about ObjectWaiters, so we'll have to reconcile that code.
    // See next_waiter(), first_waiter(), etc.

    class ObjectWaiter : public StackObj {

    ((cite: hotspot/src/share/vm/runtime/objectMonitor.hpp))
      enum TStates { TS_UNDEF, TS_READY, TS_RUN, TS_WAIT, TS_ENTER, TS_CXQ } ;

    ((cite: hotspot/src/share/vm/runtime/objectMonitor.hpp))
      enum Sorted  { PREPEND, APPEND, SORTED } ;

    ((cite: hotspot/src/share/vm/runtime/objectMonitor.hpp))
      ObjectWaiter * volatile _next;
      ObjectWaiter * volatile _prev;
      Thread*       _thread;
      ParkEvent *   _event;
      volatile int  _notified ;
      volatile TStates TState ;
      Sorted        _Sorted ;           // List placement disposition
      bool          _active ;           // Contention monitoring is enabled