src/hotspot/share/gc/z/zLock.inline.hpp

*** 23,37 ****
--- 23,44 ----
  
  #ifndef SHARE_GC_Z_ZLOCK_INLINE_HPP
  #define SHARE_GC_Z_ZLOCK_INLINE_HPP
  
  #include "gc/z/zLock.hpp"
+ #include "runtime/atomic.hpp"
+ #include "runtime/thread.hpp"
+ #include "utilities/debug.hpp"
  
  inline ZLock::ZLock() {
    pthread_mutex_init(&_lock, NULL);
  }
  
+ inline ZLock::~ZLock() {
+   pthread_mutex_destroy(&_lock);
+ }
+ 
  inline void ZLock::lock() {
    pthread_mutex_lock(&_lock);
  }
  
  inline bool ZLock::try_lock() {
*** 40,54 ****
  
  inline void ZLock::unlock() {
    pthread_mutex_unlock(&_lock);
  }
  
! inline ZLocker::ZLocker(ZLock* lock) :
      _lock(lock) {
    _lock->lock();
  }
  
! inline ZLocker::~ZLocker() {
    _lock->unlock();
  }
  
  #endif // SHARE_GC_Z_ZLOCK_INLINE_HPP
--- 47,98 ----
  
  inline void ZLock::unlock() {
    pthread_mutex_unlock(&_lock);
  }
  
! inline ZReentrantLock::ZReentrantLock() :
!     _lock(),
!     _owner(NULL),
!     _count(0) {}
! 
! inline void ZReentrantLock::lock() {
!   Thread* const thread = Thread::current();
!   Thread* const owner = Atomic::load(&_owner);
! 
!   if (owner != thread) {
!     _lock.lock();
!     Atomic::store(thread, &_owner);
!   }
! 
!   _count++;
! }
! 
! inline void ZReentrantLock::unlock() {
!   assert(is_owned(), "Invalid owner");
!   assert(_count > 0, "Invalid count");
! 
!   _count--;
! 
!   if (_count == 0) {
!     Atomic::store((Thread*)NULL, &_owner);
!     _lock.unlock();
!   }
! }
! 
! inline bool ZReentrantLock::is_owned() const {
!   Thread* const thread = Thread::current();
!   Thread* const owner = Atomic::load(&_owner);
!   return owner == thread;
! }
! 
! template <typename T>
! inline ZLocker<T>::ZLocker(T* lock) :
      _lock(lock) {
    _lock->lock();
  }
  
! template <typename T>
! inline ZLocker<T>::~ZLocker() {
    _lock->unlock();
  }
  
  #endif // SHARE_GC_Z_ZLOCK_INLINE_HPP