81     if (_lock != NULL) {
  82       _lock->lock();
  83     }
  84   }
  85 
  86   ~ShenandoahLocker() {
  87     if (_lock != NULL) {
  88       _lock->unlock();
  89     }
  90   }
  91 };
  92 
  93 class ShenandoahSimpleLock {
  94 private:
  95   os::PlatformMonitor   _lock; // native lock
  96 public:
  97   ShenandoahSimpleLock();
  98 
  99   virtual void lock();
 100   virtual void unlock();

 101 };
 102 
 103 class ShenandoahReentrantLock : public ShenandoahSimpleLock {
 104 private:
 105   Thread* volatile      _owner;
 106   uint64_t              _count;
 107 
 108 public:
 109   ShenandoahReentrantLock();
 110   ~ShenandoahReentrantLock();
 111 
 112   virtual void lock();
 113   virtual void unlock();

 114 
 115   // If the lock already owned by this thread
 116   bool owned_by_self() const ;
 117 };
 118 
 119 class ShenandoahReentrantLocker : public StackObj {
 120 private:
 121   ShenandoahReentrantLock* const _lock;
 122 
 123 public:
 124   ShenandoahReentrantLocker(ShenandoahReentrantLock* lock) :
 125     _lock(lock) {
 126     if (_lock != NULL) {
 127       _lock->lock();
 128     }
 129   }
 130 
 131   ~ShenandoahReentrantLocker() {
 132     if (_lock != NULL) {
 133       assert(_lock->owned_by_self(), "Must be owner");

  81     if (_lock != NULL) {
  82       _lock->lock();
  83     }
  84   }
  85 
  86   ~ShenandoahLocker() {
  87     if (_lock != NULL) {
  88       _lock->unlock();
  89     }
  90   }
  91 };
  92 
  93 class ShenandoahSimpleLock {
  94 private:
  95   os::PlatformMonitor   _lock; // native lock
  96 public:
  97   ShenandoahSimpleLock();
  98 
  99   virtual void lock();
 100   virtual void unlock();
 101   virtual bool try_lock();
 102 };
 103 
 104 class ShenandoahReentrantLock : public ShenandoahSimpleLock {
 105 private:
 106   Thread* volatile      _owner;
 107   uint64_t              _count;
 108 
 109 public:
 110   ShenandoahReentrantLock();
 111   ~ShenandoahReentrantLock();
 112 
 113   virtual void lock();
 114   virtual void unlock();
 115   virtual bool try_lock();
 116 
 117   // If the lock already owned by this thread
 118   bool owned_by_self() const ;
 119 };
 120 
 121 class ShenandoahReentrantLocker : public StackObj {
 122 private:
 123   ShenandoahReentrantLock* const _lock;
 124 
 125 public:
 126   ShenandoahReentrantLocker(ShenandoahReentrantLock* lock) :
 127     _lock(lock) {
 128     if (_lock != NULL) {
 129       _lock->lock();
 130     }
 131   }
 132 
 133   ~ShenandoahReentrantLocker() {
 134     if (_lock != NULL) {
 135       assert(_lock->owned_by_self(), "Must be owner");