diff a/src/hotspot/share/gc/z/zLiveMap.cpp b/src/hotspot/share/gc/z/zLiveMap.cpp
--- a/src/hotspot/share/gc/z/zLiveMap.cpp
+++ b/src/hotspot/share/gc/z/zLiveMap.cpp
@@ -118,11 +118,11 @@
   } else {
     _bitmap.clear_range(start_index, end_index);
   }
 
   // Set live bit
-  const bool success = set_segment_live_atomic(segment);
+  const bool success = set_segment_live(segment);
   assert(success, "Should never fail");
 }
 
 void ZLiveMap::resize(uint32_t size) {
   const size_t new_bitmap_size = bitmap_size(size, nsegments);
diff a/src/hotspot/share/gc/z/zLiveMap.hpp b/src/hotspot/share/gc/z/zLiveMap.hpp
--- a/src/hotspot/share/gc/z/zLiveMap.hpp
+++ b/src/hotspot/share/gc/z/zLiveMap.hpp
@@ -53,11 +53,11 @@
 
   BitMap::idx_t segment_start(BitMap::idx_t segment) const;
   BitMap::idx_t segment_end(BitMap::idx_t segment) const;
 
   bool is_segment_live(BitMap::idx_t segment) const;
-  bool set_segment_live_atomic(BitMap::idx_t segment);
+  bool set_segment_live(BitMap::idx_t segment);
 
   BitMap::idx_t first_live_segment() const;
   BitMap::idx_t next_live_segment(BitMap::idx_t segment) const;
   BitMap::idx_t index_to_segment(BitMap::idx_t index) const;
 
@@ -78,13 +78,13 @@
 
   uint32_t live_objects() const;
   size_t live_bytes() const;
 
   bool get(size_t index) const;
-  bool set_atomic(size_t index, bool finalizable, bool& inc_live);
+  bool set(size_t index, bool finalizable, bool& inc_live);
 
-  void inc_live_atomic(uint32_t objects, size_t bytes);
+  void inc_live(uint32_t objects, size_t bytes);
 
   void iterate(ObjectClosure* cl, uintptr_t page_start, size_t page_object_alignment_shift);
 };
 
 #endif // SHARE_GC_Z_ZLIVEMAP_HPP
diff a/src/hotspot/share/gc/z/zLiveMap.inline.hpp b/src/hotspot/share/gc/z/zLiveMap.inline.hpp
--- a/src/hotspot/share/gc/z/zLiveMap.inline.hpp
+++ b/src/hotspot/share/gc/z/zLiveMap.inline.hpp
@@ -70,11 +70,11 @@
 
 inline bool ZLiveMap::is_segment_live(BitMap::idx_t segment) const {
   return segment_live_bits().par_at(segment);
 }
 
-inline bool ZLiveMap::set_segment_live_atomic(BitMap::idx_t segment) {
+inline bool ZLiveMap::set_segment_live(BitMap::idx_t segment) {
   return segment_live_bits().par_set_bit(segment, memory_order_release);
 }
 
 inline bool ZLiveMap::claim_segment(BitMap::idx_t segment) {
   return segment_claim_bits().par_set_bit(segment, memory_order_acq_rel);
@@ -101,11 +101,11 @@
   return is_marked() &&              // Page is marked
          is_segment_live(segment) && // Segment is marked
          _bitmap.at(index);          // Object is marked
 }
 
-inline bool ZLiveMap::set_atomic(size_t index, bool finalizable, bool& inc_live) {
+inline bool ZLiveMap::set(size_t index, bool finalizable, bool& inc_live) {
   if (!is_marked()) {
     // First object to be marked during this
     // cycle, reset marking information.
     reset(index);
   }
@@ -118,11 +118,11 @@
   }
 
   return _bitmap.par_set_bit_pair(index, finalizable, inc_live);
 }
 
-inline void ZLiveMap::inc_live_atomic(uint32_t objects, size_t bytes) {
+inline void ZLiveMap::inc_live(uint32_t objects, size_t bytes) {
   Atomic::add(objects, &_live_objects);
   Atomic::add(bytes, &_live_bytes);
 }
 
 inline BitMap::idx_t ZLiveMap::segment_start(BitMap::idx_t segment) const {
diff a/src/hotspot/share/gc/z/zMarkCache.inline.hpp b/src/hotspot/share/gc/z/zMarkCache.inline.hpp
--- a/src/hotspot/share/gc/z/zMarkCache.inline.hpp
+++ b/src/hotspot/share/gc/z/zMarkCache.inline.hpp
@@ -42,11 +42,11 @@
 }
 
 inline void ZMarkCacheEntry::evict() {
   if (_page != NULL) {
     // Write cached data out to page
-    _page->inc_live_atomic(_objects, _bytes);
+    _page->inc_live(_objects, _bytes);
     _page = NULL;
   }
 }
 
 inline void ZMarkCache::inc_live(ZPage* page, size_t bytes) {
diff a/src/hotspot/share/gc/z/zMarkStack.hpp b/src/hotspot/share/gc/z/zMarkStack.hpp
--- a/src/hotspot/share/gc/z/zMarkStack.hpp
+++ b/src/hotspot/share/gc/z/zMarkStack.hpp
@@ -60,12 +60,12 @@
 public:
   ZStackList();
 
   bool is_empty() const;
 
-  void push_atomic(T* stack);
-  T* pop_atomic();
+  void push(T* stack);
+  T* pop();
 };
 
 typedef ZStack<ZMarkStackEntry, ZMarkStackSlots>     ZMarkStack;
 typedef ZStackList<ZMarkStack>                       ZMarkStackList;
 typedef ZStack<ZMarkStack*, ZMarkStackMagazineSlots> ZMarkStackMagazine;
diff a/src/hotspot/share/gc/z/zMarkStack.inline.hpp b/src/hotspot/share/gc/z/zMarkStack.inline.hpp
--- a/src/hotspot/share/gc/z/zMarkStack.inline.hpp
+++ b/src/hotspot/share/gc/z/zMarkStack.inline.hpp
@@ -112,11 +112,11 @@
   decode_versioned_pointer(vstack, &stack, &version);
   return stack == NULL;
 }
 
 template <typename T>
-inline void ZStackList<T>::push_atomic(T* stack) {
+inline void ZStackList<T>::push(T* stack) {
   T* vstack = _head;
   uint32_t version = 0;
 
   for (;;) {
     decode_versioned_pointer(vstack, stack->next_addr(), &version);
@@ -131,11 +131,11 @@
     vstack = prev_vstack;
   }
 }
 
 template <typename T>
-inline T* ZStackList<T>::pop_atomic() {
+inline T* ZStackList<T>::pop() {
   T* vstack = _head;
   T* stack = NULL;
   uint32_t version = 0;
 
   for (;;) {
@@ -166,24 +166,24 @@
   // workers to work on, while the overflowed list is used by GC workers
   // to publish stacks that overflowed. The intention here is to avoid
   // contention between mutators and GC workers as much as possible, while
   // still allowing GC workers to help out and steal work from each other.
   if (publish) {
-    _published.push_atomic(stack);
+    _published.push(stack);
   } else {
-    _overflowed.push_atomic(stack);
+    _overflowed.push(stack);
   }
 }
 
 inline ZMarkStack* ZMarkStripe::steal_stack() {
   // Steal overflowed stacks first, then published stacks
-  ZMarkStack* const stack = _overflowed.pop_atomic();
+  ZMarkStack* const stack = _overflowed.pop();
   if (stack != NULL) {
     return stack;
   }
 
-  return _published.pop_atomic();
+  return _published.pop();
 }
 
 inline size_t ZMarkStripeSet::nstripes() const {
   return _nstripes;
 }
diff a/src/hotspot/share/gc/z/zMarkStackAllocator.cpp b/src/hotspot/share/gc/z/zMarkStackAllocator.cpp
--- a/src/hotspot/share/gc/z/zMarkStackAllocator.cpp
+++ b/src/hotspot/share/gc/z/zMarkStackAllocator.cpp
@@ -164,11 +164,11 @@
   return magazine;
 }
 
 ZMarkStackMagazine* ZMarkStackAllocator::alloc_magazine() {
   // Try allocating from the free list first
-  ZMarkStackMagazine* const magazine = _freelist.pop_atomic();
+  ZMarkStackMagazine* const magazine = _freelist.pop();
   if (magazine != NULL) {
     return magazine;
   }
 
   // Allocate new magazine
@@ -179,7 +179,7 @@
 
   return create_magazine_from_space(addr, ZMarkStackMagazineSize);
 }
 
 void ZMarkStackAllocator::free_magazine(ZMarkStackMagazine* magazine) {
-  _freelist.push_atomic(magazine);
+  _freelist.push(magazine);
 }
diff a/src/hotspot/share/gc/z/zPage.hpp b/src/hotspot/share/gc/z/zPage.hpp
--- a/src/hotspot/share/gc/z/zPage.hpp
+++ b/src/hotspot/share/gc/z/zPage.hpp
@@ -94,11 +94,11 @@
   bool is_marked() const;
   bool is_object_live(uintptr_t addr) const;
   bool is_object_strongly_live(uintptr_t addr) const;
   bool mark_object(uintptr_t addr, bool finalizable, bool& inc_live);
 
-  void inc_live_atomic(uint32_t objects, size_t bytes);
+  void inc_live(uint32_t objects, size_t bytes);
   uint32_t live_objects() const;
   size_t live_bytes() const;
 
   void object_iterate(ObjectClosure* cl);
 
diff a/src/hotspot/share/gc/z/zPage.inline.hpp b/src/hotspot/share/gc/z/zPage.inline.hpp
--- a/src/hotspot/share/gc/z/zPage.inline.hpp
+++ b/src/hotspot/share/gc/z/zPage.inline.hpp
@@ -205,15 +205,15 @@
   assert(is_relocatable(), "Invalid page state");
   assert(is_in(addr), "Invalid address");
 
   // Set mark bit
   const size_t index = ((ZAddress::offset(addr) - start()) >> object_alignment_shift()) * 2;
-  return _livemap.set_atomic(index, finalizable, inc_live);
+  return _livemap.set(index, finalizable, inc_live);
 }
 
-inline void ZPage::inc_live_atomic(uint32_t objects, size_t bytes) {
-  _livemap.inc_live_atomic(objects, bytes);
+inline void ZPage::inc_live(uint32_t objects, size_t bytes) {
+  _livemap.inc_live(objects, bytes);
 }
 
 inline uint32_t ZPage::live_objects() const {
   assert(is_marked(), "Should be marked");
   return _livemap.live_objects();
diff a/test/hotspot/gtest/gc/z/test_zForwarding.cpp b/test/hotspot/gtest/gc/z/test_zForwarding.cpp
--- a/test/hotspot/gtest/gc/z/test_zForwarding.cpp
+++ b/test/hotspot/gtest/gc/z/test_zForwarding.cpp
@@ -157,11 +157,11 @@
     bool dummy = false;
     page.mark_object(ZAddress::marked(object), dummy, dummy);
 
     const uint32_t live_objects = size;
     const size_t live_bytes = live_objects * object_size;
-    page.inc_live_atomic(live_objects, live_bytes);
+    page.inc_live(live_objects, live_bytes);
 
     // Setup forwarding
     ZForwarding* const forwarding = ZForwarding::create(&page);
 
     // Actual test function
diff a/test/hotspot/gtest/gc/z/test_zLiveMap.cpp b/test/hotspot/gtest/gc/z/test_zLiveMap.cpp
--- a/test/hotspot/gtest/gc/z/test_zLiveMap.cpp
+++ b/test/hotspot/gtest/gc/z/test_zLiveMap.cpp
@@ -33,11 +33,11 @@
 
     bool inc_live;
     uintptr_t object = 0u;
 
     // Mark the object strong.
-    livemap.set_atomic(object, false /* finalizable */, inc_live);
+    livemap.set(object, false /* finalizable */, inc_live);
 
     // Check that both bits are in the same segment.
     ASSERT_EQ(livemap.index_to_segment(0), livemap.index_to_segment(1));
 
     // Check that the object was marked.