--- old/src/hotspot/share/gc/z/zLock.hpp	2019-10-09 14:05:57.613846038 +0200
+++ new/src/hotspot/share/gc/z/zLock.hpp	2019-10-09 14:05:57.355837651 +0200
@@ -52,6 +52,13 @@
   bool is_owned() const;
 };
 
+class ZNoLock {
+public:
+  void lock();
+  bool try_lock();
+  void unlock();
+};
+
 template <typename T>
 class ZLocker : public StackObj {
 private:
--- old/src/hotspot/share/gc/z/zLock.inline.hpp	2019-10-09 14:05:57.987858196 +0200
+++ new/src/hotspot/share/gc/z/zLock.inline.hpp	2019-10-09 14:05:57.718849451 +0200
@@ -77,6 +77,18 @@
   return owner == thread;
 }
 
+inline void ZNoLock::lock() {
+  // Does nothing
+}
+
+inline bool ZNoLock::try_lock() {
+  return true;
+}
+
+inline void ZNoLock::unlock() {
+  // Does nothing
+}
+
 template <typename T>
 inline ZLocker<T>::ZLocker(T* lock) :
     _lock(lock) {
--- old/src/hotspot/share/gc/z/zNMethodTable.cpp	2019-10-09 14:05:58.427872499 +0200
+++ new/src/hotspot/share/gc/z/zNMethodTable.cpp	2019-10-09 14:05:58.093861642 +0200
@@ -51,7 +51,7 @@
 size_t ZNMethodTable::_nregistered = 0;
 size_t ZNMethodTable::_nunregistered = 0;
 ZNMethodTableIteration ZNMethodTable::_iteration;
-ZSafeDelete<ZNMethodTableEntry[]> ZNMethodTable::_safe_delete;
+ZSafeDeleteNoLock<ZNMethodTableEntry[]> ZNMethodTable::_safe_delete;
 
 size_t ZNMethodTable::first_index(const nmethod* nm, size_t size) {
   assert(is_power_of_2(size), "Invalid size");
--- old/src/hotspot/share/gc/z/zNMethodTable.hpp	2019-10-09 14:05:58.815885112 +0200
+++ new/src/hotspot/share/gc/z/zNMethodTable.hpp	2019-10-09 14:05:58.545876335 +0200
@@ -35,12 +35,12 @@
 
 class ZNMethodTable : public AllStatic {
 private:
-  static ZNMethodTableEntry*               _table;
-  static size_t                            _size;
-  static size_t                            _nregistered;
-  static size_t                            _nunregistered;
-  static ZNMethodTableIteration            _iteration;
-  static ZSafeDelete<ZNMethodTableEntry[]> _safe_delete;
+  static ZNMethodTableEntry*                     _table;
+  static size_t                                  _size;
+  static size_t                                  _nregistered;
+  static size_t                                  _nunregistered;
+  static ZNMethodTableIteration                  _iteration;
+  static ZSafeDeleteNoLock<ZNMethodTableEntry[]> _safe_delete;
 
   static ZNMethodTableEntry* create(size_t size);
   static void destroy(ZNMethodTableEntry* table);
--- old/src/hotspot/share/gc/z/zSafeDelete.hpp	2019-10-09 14:05:59.198897563 +0200
+++ new/src/hotspot/share/gc/z/zSafeDelete.hpp	2019-10-09 14:05:58.927888753 +0200
@@ -28,12 +28,12 @@
 #include "gc/z/zLock.hpp"
 #include "metaprogramming/removeExtent.hpp"
 
-template <typename T>
-class ZSafeDelete {
+template <typename LockT, typename T>
+class ZSafeDeleteImpl {
 private:
   typedef typename RemoveExtent<T>::type ItemT;
 
-  ZLock          _lock;
+  LockT          _lock;
   uint64_t       _enabled;
   ZArray<ItemT*> _deferred;
 
@@ -41,7 +41,7 @@
   void immediate_delete(ItemT* item);
 
 public:
-  ZSafeDelete();
+  ZSafeDeleteImpl();
 
   void enable_deferred_delete();
   void disable_deferred_delete();
@@ -49,4 +49,10 @@
   void operator()(ItemT* item);
 };
 
+template <typename T>
+class ZSafeDelete : public ZSafeDeleteImpl<ZLock, T> {};
+
+template <typename T>
+class ZSafeDeleteNoLock : public ZSafeDeleteImpl<ZNoLock, T> {};
+
 #endif // SHARE_GC_Z_ZSAFEDELETE_HPP
--- old/src/hotspot/share/gc/z/zSafeDelete.inline.hpp	2019-10-09 14:05:59.634911736 +0200
+++ new/src/hotspot/share/gc/z/zSafeDelete.inline.hpp	2019-10-09 14:05:59.303900976 +0200
@@ -29,15 +29,15 @@
 #include "metaprogramming/isArray.hpp"
 #include "utilities/debug.hpp"
 
-template <typename T>
-ZSafeDelete<T>::ZSafeDelete() :
+template <typename LockT, typename T>
+ZSafeDeleteImpl<LockT, T>::ZSafeDeleteImpl() :
     _lock(),
     _enabled(0),
     _deferred() {}
 
-template <typename T>
-bool ZSafeDelete<T>::deferred_delete(ItemT* item) {
-  ZLocker<ZLock> locker(&_lock);
+template <typename LockT, typename T>
+bool ZSafeDeleteImpl<LockT, T>::deferred_delete(ItemT* item) {
+  ZLocker<LockT> locker(&_lock);
   if (_enabled > 0) {
     _deferred.add(item);
     return true;
@@ -46,8 +46,8 @@
   return false;
 }
 
-template <typename T>
-void ZSafeDelete<T>::immediate_delete(ItemT* item) {
+template <typename LockT, typename T>
+void ZSafeDeleteImpl<LockT, T>::immediate_delete(ItemT* item) {
   if (IsArray<T>::value) {
     delete [] item;
   } else {
@@ -55,18 +55,18 @@
   }
 }
 
-template <typename T>
-void ZSafeDelete<T>::enable_deferred_delete() {
-  ZLocker<ZLock> locker(&_lock);
+template <typename LockT, typename T>
+void ZSafeDeleteImpl<LockT, T>::enable_deferred_delete() {
+  ZLocker<LockT> locker(&_lock);
   _enabled++;
 }
 
-template <typename T>
-void ZSafeDelete<T>::disable_deferred_delete() {
+template <typename LockT, typename T>
+void ZSafeDeleteImpl<LockT, T>::disable_deferred_delete() {
   ZArray<ItemT*> deferred;
 
   {
-    ZLocker<ZLock> locker(&_lock);
+    ZLocker<LockT> locker(&_lock);
     assert(_enabled > 0, "Invalid state");
     if (--_enabled == 0) {
       deferred.transfer(&_deferred);
@@ -79,8 +79,8 @@
   }
 }
 
-template <typename T>
-void ZSafeDelete<T>::operator()(ItemT* item) {
+template <typename LockT, typename T>
+void ZSafeDeleteImpl<LockT, T>::operator()(ItemT* item) {
   if (!deferred_delete(item)) {
     immediate_delete(item);
   }