diff --git a/src/hotspot/share/classfile/javaClasses.cpp b/src/hotspot/share/classfile/javaClasses.cpp
index 0e8467289ad2d..fba4d1c5d4b4e 100644
--- a/src/hotspot/share/classfile/javaClasses.cpp
+++ b/src/hotspot/share/classfile/javaClasses.cpp
@@ -1899,7 +1899,7 @@ oop java_lang_Thread::async_get_stack_trace(oop java_thread, TRAPS) {
     return nullptr;
   }
 
-  class GetStackTraceClosure : public HandshakeClosure {
+  class GetStackTraceHandshakeClosure : public HandshakeClosure {
   public:
     const Handle _java_thread;
     int _depth;
@@ -1907,11 +1907,11 @@ oop java_lang_Thread::async_get_stack_trace(oop java_thread, TRAPS) {
     GrowableArray<Method*>* _methods;
     GrowableArray<int>*     _bcis;
 
-    GetStackTraceClosure(Handle java_thread) :
-        HandshakeClosure("GetStackTraceClosure"), _java_thread(java_thread), _depth(0), _retry_handshake(false),
+    GetStackTraceHandshakeClosure(Handle java_thread) :
+        HandshakeClosure("GetStackTraceHandshakeClosure"), _java_thread(java_thread), _depth(0), _retry_handshake(false),
         _methods(nullptr), _bcis(nullptr) {
     }
-    ~GetStackTraceClosure() {
+    ~GetStackTraceHandshakeClosure() {
       delete _methods;
       delete _bcis;
     }
@@ -1977,13 +1977,13 @@ oop java_lang_Thread::async_get_stack_trace(oop java_thread, TRAPS) {
   // Handshake with target
   ResourceMark rm(THREAD);
   HandleMark   hm(THREAD);
-  GetStackTraceClosure gstc(Handle(THREAD, java_thread));
+  GetStackTraceHandshakeClosure gsthc(Handle(THREAD, java_thread));
   do {
-   Handshake::execute(&gstc, &tlh, thread);
-  } while (gstc.read_reset_retry());
+   Handshake::execute(&gsthc, &tlh, thread);
+  } while (gsthc.read_reset_retry());
 
   // Stop if no stack trace is found.
-  if (gstc._depth == 0) {
+  if (gsthc._depth == 0) {
     return nullptr;
   }
 
@@ -1993,12 +1993,12 @@ oop java_lang_Thread::async_get_stack_trace(oop java_thread, TRAPS) {
   if (k->should_be_initialized()) {
     k->initialize(CHECK_NULL);
   }
-  objArrayHandle trace = oopFactory::new_objArray_handle(k, gstc._depth, CHECK_NULL);
+  objArrayHandle trace = oopFactory::new_objArray_handle(k, gsthc._depth, CHECK_NULL);
 
-  for (int i = 0; i < gstc._depth; i++) {
-    methodHandle method(THREAD, gstc._methods->at(i));
+  for (int i = 0; i < gsthc._depth; i++) {
+    methodHandle method(THREAD, gsthc._methods->at(i));
     oop element = java_lang_StackTraceElement::create(method,
-                                                      gstc._bcis->at(i),
+                                                      gsthc._bcis->at(i),
                                                       CHECK_NULL);
     trace->obj_at_put(i, element);
   }
diff --git a/src/hotspot/share/gc/shenandoah/shenandoahConcurrentGC.cpp b/src/hotspot/share/gc/shenandoah/shenandoahConcurrentGC.cpp
index fda97c4836e12..2f264cae70f19 100644
--- a/src/hotspot/share/gc/shenandoah/shenandoahConcurrentGC.cpp
+++ b/src/hotspot/share/gc/shenandoah/shenandoahConcurrentGC.cpp
@@ -1145,22 +1145,22 @@ void ShenandoahConcurrentGC::op_update_refs() {
   ShenandoahHeap::heap()->update_heap_references(true /*concurrent*/);
 }
 
-class ShenandoahUpdateThreadClosure : public HandshakeClosure {
+class ShenandoahUpdateThreadHandshakeClosure : public HandshakeClosure {
 private:
   // This closure runs when thread is stopped for handshake, which means
   // we can use non-concurrent closure here, as long as it only updates
   // locations modified by the thread itself, i.e. stack locations.
   ShenandoahNonConcUpdateRefsClosure _cl;
 public:
-  ShenandoahUpdateThreadClosure();
+  ShenandoahUpdateThreadHandshakeClosure();
   void do_thread(Thread* thread);
 };
 
-ShenandoahUpdateThreadClosure::ShenandoahUpdateThreadClosure() :
+ShenandoahUpdateThreadHandshakeClosure::ShenandoahUpdateThreadHandshakeClosure() :
   HandshakeClosure("Shenandoah Update Thread Roots") {
 }
 
-void ShenandoahUpdateThreadClosure::do_thread(Thread* thread) {
+void ShenandoahUpdateThreadHandshakeClosure::do_thread(Thread* thread) {
   if (thread->is_Java_thread()) {
     JavaThread* jt = JavaThread::cast(thread);
     ResourceMark rm;
@@ -1169,7 +1169,7 @@ void ShenandoahUpdateThreadClosure::do_thread(Thread* thread) {
 }
 
 void ShenandoahConcurrentGC::op_update_thread_roots() {
-  ShenandoahUpdateThreadClosure cl;
+  ShenandoahUpdateThreadHandshakeClosure cl;
   Handshake::execute(&cl);
 }
 
diff --git a/src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp b/src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp
index 55dfb2e8de400..50881a5077833 100644
--- a/src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp
+++ b/src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp
@@ -1245,9 +1245,9 @@ class ShenandoahRetireGCLABClosure : public ThreadClosure {
   }
 };
 
-class ShenandoahGCStatePropagator : public HandshakeClosure {
+class ShenandoahGCStatePropagatorHandshakeClosure : public HandshakeClosure {
 public:
-  explicit ShenandoahGCStatePropagator(char gc_state) :
+  explicit ShenandoahGCStatePropagatorHandshakeClosure(char gc_state) :
     HandshakeClosure("Shenandoah GC State Change"),
     _gc_state(gc_state) {}
 
@@ -1258,9 +1258,9 @@ class ShenandoahGCStatePropagator : public HandshakeClosure {
   char _gc_state;
 };
 
-class ShenandoahPrepareForUpdateRefs : public HandshakeClosure {
+class ShenandoahPrepareForUpdateRefsHandshakeClosure : public HandshakeClosure {
 public:
-  explicit ShenandoahPrepareForUpdateRefs(char gc_state) :
+  explicit ShenandoahPrepareForUpdateRefsHandshakeClosure(char gc_state) :
     HandshakeClosure("Shenandoah Prepare for Update Refs"),
     _retire(ResizeTLAB), _propagator(gc_state) {}
 
@@ -1272,7 +1272,7 @@ class ShenandoahPrepareForUpdateRefs : public HandshakeClosure {
   }
 private:
   ShenandoahRetireGCLABClosure _retire;
-  ShenandoahGCStatePropagator _propagator;
+  ShenandoahGCStatePropagatorHandshakeClosure _propagator;
 };
 
 void ShenandoahHeap::evacuate_collection_set(bool concurrent) {
@@ -1295,7 +1295,7 @@ void ShenandoahHeap::concurrent_prepare_for_update_refs() {
   }
 
   // This will propagate the gc state and retire gclabs and plabs for threads that require it.
-  ShenandoahPrepareForUpdateRefs prepare_for_update_refs(_gc_state.raw_value());
+  ShenandoahPrepareForUpdateRefsHandshakeClosure prepare_for_update_refs(_gc_state.raw_value());
 
   // The handshake won't touch worker threads (or control thread, or VM thread), so do those separately.
   Threads::non_java_threads_do(&prepare_for_update_refs);
@@ -1327,7 +1327,7 @@ void ShenandoahHeap::concurrent_final_roots(HandshakeClosure* handshake_closure)
     set_gc_state_concurrent(WEAK_ROOTS, false);
   }
 
-  ShenandoahGCStatePropagator propagator(_gc_state.raw_value());
+  ShenandoahGCStatePropagatorHandshakeClosure propagator(_gc_state.raw_value());
   Threads::non_java_threads_do(&propagator);
   if (handshake_closure == nullptr) {
     Handshake::execute(&propagator);
@@ -2020,14 +2020,14 @@ void ShenandoahHeap::parallel_heap_region_iterate(ShenandoahHeapRegionClosure* b
   }
 }
 
-class ShenandoahRendezvousClosure : public HandshakeClosure {
+class ShenandoahRendezvousHandshakeClosure : public HandshakeClosure {
 public:
-  inline ShenandoahRendezvousClosure(const char* name) : HandshakeClosure(name) {}
+  inline ShenandoahRendezvousHandshakeClosure(const char* name) : HandshakeClosure(name) {}
   inline void do_thread(Thread* thread) {}
 };
 
 void ShenandoahHeap::rendezvous_threads(const char* name) {
-  ShenandoahRendezvousClosure cl(name);
+  ShenandoahRendezvousHandshakeClosure cl(name);
   Handshake::execute(&cl);
 }
 
@@ -2069,7 +2069,7 @@ void ShenandoahHeap::prepare_update_heap_references() {
 void ShenandoahHeap::propagate_gc_state_to_all_threads() {
   assert(ShenandoahSafepoint::is_at_shenandoah_safepoint(), "Must be at Shenandoah safepoint");
   if (_gc_state_changed) {
-    ShenandoahGCStatePropagator propagator(_gc_state.raw_value());
+    ShenandoahGCStatePropagatorHandshakeClosure propagator(_gc_state.raw_value());
     Threads::threads_do(&propagator);
     _gc_state_changed = false;
   }
diff --git a/src/hotspot/share/gc/z/zMark.cpp b/src/hotspot/share/gc/z/zMark.cpp
index d1646da7604d7..482b4ddd75f21 100644
--- a/src/hotspot/share/gc/z/zMark.cpp
+++ b/src/hotspot/share/gc/z/zMark.cpp
@@ -532,13 +532,13 @@ bool ZMark::try_steal(ZMarkContext* context) {
   return try_steal_local(context) || try_steal_global(context);
 }
 
-class ZMarkFlushStacksClosure : public HandshakeClosure {
+class ZMarkFlushStacksHandshakeClosure : public HandshakeClosure {
 private:
   ZMark* const _mark;
   bool         _flushed;
 
 public:
-  ZMarkFlushStacksClosure(ZMark* mark)
+  ZMarkFlushStacksHandshakeClosure(ZMark* mark)
     : HandshakeClosure("ZMarkFlushStacks"),
       _mark(mark),
       _flushed(false) {}
@@ -585,7 +585,7 @@ class VM_ZMarkFlushOperation : public VM_Operation {
 };
 
 bool ZMark::flush() {
-  ZMarkFlushStacksClosure cl(this);
+  ZMarkFlushStacksHandshakeClosure cl(this);
   VM_ZMarkFlushOperation vm_cl(&cl);
   Handshake::execute(&cl);
   VMThread::execute(&vm_cl);
@@ -956,7 +956,7 @@ bool ZMark::try_end() {
   }
 
   // Try end marking
-  ZMarkFlushStacksClosure cl(this);
+  ZMarkFlushStacksHandshakeClosure cl(this);
   Threads::non_java_threads_do(&cl);
 
   // Check if non-java threads have any pending marking
diff --git a/src/hotspot/share/prims/scopedMemoryAccess.cpp b/src/hotspot/share/prims/scopedMemoryAccess.cpp
index 8ef5b96f37d04..c1d1b8cd8c005 100644
--- a/src/hotspot/share/prims/scopedMemoryAccess.cpp
+++ b/src/hotspot/share/prims/scopedMemoryAccess.cpp
@@ -105,15 +105,15 @@ static frame get_last_frame(JavaThread* jt) {
   return last_frame;
 }
 
-class ScopedAsyncExceptionHandshake : public AsyncExceptionHandshake {
+class ScopedAsyncExceptionHandshakeClosure : public AsyncExceptionHandshakeClosure {
   OopHandle _session;
 
 public:
-  ScopedAsyncExceptionHandshake(OopHandle& session, OopHandle& error)
-    : AsyncExceptionHandshake(error),
+  ScopedAsyncExceptionHandshakeClosure(OopHandle& session, OopHandle& error)
+    : AsyncExceptionHandshakeClosure(error),
       _session(session) {}
 
-  ~ScopedAsyncExceptionHandshake() {
+  ~ScopedAsyncExceptionHandshakeClosure() {
     _session.release(Universe::vm_global());
   }
 
@@ -122,17 +122,17 @@ class ScopedAsyncExceptionHandshake : public AsyncExceptionHandshake {
     bool ignored;
     if (is_accessing_session(jt, _session.resolve(), ignored)) {
       // Throw exception to unwind out from the scoped access
-      AsyncExceptionHandshake::do_thread(thread);
+      AsyncExceptionHandshakeClosure::do_thread(thread);
     }
   }
 };
 
-class CloseScopedMemoryClosure : public HandshakeClosure {
+class CloseScopedMemoryHandshakeClosure : public HandshakeClosure {
   jobject _session;
   jobject _error;
 
 public:
-  CloseScopedMemoryClosure(jobject session, jobject error)
+  CloseScopedMemoryHandshakeClosure(jobject session, jobject error)
     : HandshakeClosure("CloseScopedMemory")
     , _session(session)
     , _error(error) {}
@@ -159,7 +159,7 @@ class CloseScopedMemoryClosure : public HandshakeClosure {
       // the scoped access.
       OopHandle session(Universe::vm_global(), JNIHandles::resolve(_session));
       OopHandle error(Universe::vm_global(), JNIHandles::resolve(_error));
-      jt->install_async_exception(new ScopedAsyncExceptionHandshake(session, error));
+      jt->install_async_exception(new ScopedAsyncExceptionHandshakeClosure(session, error));
     } else if (!in_scoped) {
       frame last_frame = get_last_frame(jt);
       if (last_frame.is_compiled_frame() && last_frame.can_be_deoptimized()) {
@@ -213,7 +213,7 @@ class CloseScopedMemoryClosure : public HandshakeClosure {
  * closed (deopt), this method returns false, signalling that the session cannot be closed safely.
  */
 JVM_ENTRY(void, ScopedMemoryAccess_closeScope(JNIEnv *env, jobject receiver, jobject session, jobject error))
-  CloseScopedMemoryClosure cl(session, error);
+  CloseScopedMemoryHandshakeClosure cl(session, error);
   Handshake::execute(&cl);
 JVM_END
 
diff --git a/src/hotspot/share/prims/whitebox.cpp b/src/hotspot/share/prims/whitebox.cpp
index 60ebba36f924a..9beb50fe78b52 100644
--- a/src/hotspot/share/prims/whitebox.cpp
+++ b/src/hotspot/share/prims/whitebox.cpp
@@ -2246,7 +2246,7 @@ WB_END
 #endif // INCLUDE_CDS
 
 WB_ENTRY(jboolean, WB_HandshakeReadMonitors(JNIEnv* env, jobject wb, jobject thread_handle))
-  class ReadMonitorsClosure : public HandshakeClosure {
+  class ReadMonitorsHandshakeClosure : public HandshakeClosure {
     jboolean _executed;
 
     void do_thread(Thread* th) {
@@ -2281,24 +2281,24 @@ WB_ENTRY(jboolean, WB_HandshakeReadMonitors(JNIEnv* env, jobject wb, jobject thr
     }
 
    public:
-    ReadMonitorsClosure() : HandshakeClosure("WB_HandshakeReadMonitors"), _executed(false) {}
+    ReadMonitorsHandshakeClosure() : HandshakeClosure("WB_HandshakeReadMonitors"), _executed(false) {}
     jboolean executed() const { return _executed; }
   };
 
-  ReadMonitorsClosure rmc;
+  ReadMonitorsHandshakeClosure rmhc;
   if (thread_handle != nullptr) {
     ThreadsListHandle tlh;
     JavaThread* target = nullptr;
     bool is_alive = tlh.cv_internal_thread_to_JavaThread(thread_handle, &target, nullptr);
     if (is_alive) {
-      Handshake::execute(&rmc, &tlh, target);
+      Handshake::execute(&rmhc, &tlh, target);
     }
   }
-  return rmc.executed();
+  return rmhc.executed();
 WB_END
 
 WB_ENTRY(jint, WB_HandshakeWalkStack(JNIEnv* env, jobject wb, jobject thread_handle, jboolean all_threads))
-  class TraceSelfClosure : public HandshakeClosure {
+  class TraceSelfHandshakeClosure : public HandshakeClosure {
     jint _num_threads_completed;
 
     void do_thread(Thread* th) {
@@ -2312,27 +2312,27 @@ WB_ENTRY(jint, WB_HandshakeWalkStack(JNIEnv* env, jobject wb, jobject thread_han
     }
 
   public:
-    TraceSelfClosure(Thread* thread) : HandshakeClosure("WB_TraceSelf"), _num_threads_completed(0) {}
+    TraceSelfHandshakeClosure(Thread* thread) : HandshakeClosure("WB_TraceSelf"), _num_threads_completed(0) {}
 
     jint num_threads_completed() const { return _num_threads_completed; }
   };
-  TraceSelfClosure tsc(Thread::current());
+  TraceSelfHandshakeClosure tshc(Thread::current());
 
   if (all_threads) {
-    Handshake::execute(&tsc);
+    Handshake::execute(&tshc);
   } else if (thread_handle != nullptr) {
     ThreadsListHandle tlh;
     JavaThread* target = nullptr;
     bool is_alive = tlh.cv_internal_thread_to_JavaThread(thread_handle, &target, nullptr);
     if (is_alive) {
-      Handshake::execute(&tsc, &tlh, target);
+      Handshake::execute(&tshc, &tlh, target);
     }
   }
-  return tsc.num_threads_completed();
+  return tshc.num_threads_completed();
 WB_END
 
 WB_ENTRY(void, WB_AsyncHandshakeWalkStack(JNIEnv* env, jobject wb, jobject thread_handle))
-  class TraceSelfClosure : public AsyncHandshakeClosure {
+  class TraceSelfHandshakeClosure : public AsyncHandshakeClosure {
     JavaThread* _self;
     void do_thread(Thread* th) {
       assert(th->is_Java_thread(), "sanity");
@@ -2347,15 +2347,15 @@ WB_ENTRY(void, WB_AsyncHandshakeWalkStack(JNIEnv* env, jobject wb, jobject threa
     }
 
   public:
-    TraceSelfClosure(JavaThread* self_target) : AsyncHandshakeClosure("WB_TraceSelf"), _self(self_target) {}
+    TraceSelfHandshakeClosure(JavaThread* self_target) : AsyncHandshakeClosure("WB_TraceSelf"), _self(self_target) {}
   };
   if (thread_handle != nullptr) {
     ThreadsListHandle tlh;
     JavaThread* target = nullptr;
     bool is_alive = tlh.cv_internal_thread_to_JavaThread(thread_handle, &target, nullptr);
     if (is_alive) {
-      TraceSelfClosure* tsc = new TraceSelfClosure(target);
-      Handshake::execute(tsc, target);
+      TraceSelfHandshakeClosure* tshc = new TraceSelfHandshakeClosure(target);
+      Handshake::execute(tshc, target);
     }
   }
 WB_END
diff --git a/src/hotspot/share/runtime/deoptimization.cpp b/src/hotspot/share/runtime/deoptimization.cpp
index ceb09811f73b5..ae5a81cf3ac96 100644
--- a/src/hotspot/share/runtime/deoptimization.cpp
+++ b/src/hotspot/share/runtime/deoptimization.cpp
@@ -1049,9 +1049,9 @@ JRT_LEAF(BasicType, Deoptimization::unpack_frames(JavaThread* thread, int exec_m
   return bt;
 JRT_END
 
-class DeoptimizeMarkedClosure : public HandshakeClosure {
+class DeoptimizeMarkedHandshakeClosure : public HandshakeClosure {
  public:
-  DeoptimizeMarkedClosure() : HandshakeClosure("Deoptimize") {}
+  DeoptimizeMarkedHandshakeClosure() : HandshakeClosure("Deoptimize") {}
   void do_thread(Thread* thread) {
     JavaThread* jt = JavaThread::cast(thread);
     jt->deoptimize_marked_methods();
@@ -1064,7 +1064,7 @@ void Deoptimization::deoptimize_all_marked() {
   // Make the dependent methods not entrant
   CodeCache::make_marked_nmethods_deoptimized();
 
-  DeoptimizeMarkedClosure deopt;
+  DeoptimizeMarkedHandshakeClosure deopt;
   if (SafepointSynchronize::is_at_safepoint()) {
     Threads::java_threads_do(&deopt);
   } else {
diff --git a/src/hotspot/share/runtime/escapeBarrier.cpp b/src/hotspot/share/runtime/escapeBarrier.cpp
index 8f9a8b59dd6ce..2005527bb8bfc 100644
--- a/src/hotspot/share/runtime/escapeBarrier.cpp
+++ b/src/hotspot/share/runtime/escapeBarrier.cpp
@@ -165,9 +165,9 @@ bool EscapeBarrier::deoptimize_objects_all_threads() {
 bool EscapeBarrier::_deoptimizing_objects_for_all_threads = false;
 bool EscapeBarrier::_self_deoptimization_in_progress      = false;
 
-class EscapeBarrierSuspendHandshake : public HandshakeClosure {
+class EscapeBarrierSuspendHandshakeClosure : public HandshakeClosure {
  public:
-  EscapeBarrierSuspendHandshake(const char* name) :
+  EscapeBarrierSuspendHandshakeClosure(const char* name) :
     HandshakeClosure(name) { }
   void do_thread(Thread* th) { }
 };
@@ -196,7 +196,7 @@ void EscapeBarrier::sync_and_suspend_one() {
   }
 
   // Use a handshake to synchronize with the target thread.
-  EscapeBarrierSuspendHandshake sh("EscapeBarrierSuspendOne");
+  EscapeBarrierSuspendHandshakeClosure sh("EscapeBarrierSuspendOne");
   Handshake::execute(&sh, _deoptee_thread);
   assert(!_deoptee_thread->has_last_Java_frame() || _deoptee_thread->frame_anchor()->walkable(),
          "stack should be walkable now");
@@ -242,7 +242,7 @@ void EscapeBarrier::sync_and_suspend_all() {
   }
 
   // Use a handshake to synchronize with the other threads.
-  EscapeBarrierSuspendHandshake sh("EscapeBarrierSuspendAll");
+  EscapeBarrierSuspendHandshakeClosure sh("EscapeBarrierSuspendAll");
   Handshake::execute(&sh);
 #ifdef ASSERT
   for (JavaThreadIteratorWithHandle jtiwh; JavaThread *jt = jtiwh.next(); ) {
diff --git a/src/hotspot/share/runtime/handshake.cpp b/src/hotspot/share/runtime/handshake.cpp
index 2c827b61602c7..c55803242de15 100644
--- a/src/hotspot/share/runtime/handshake.cpp
+++ b/src/hotspot/share/runtime/handshake.cpp
@@ -705,7 +705,7 @@ void HandshakeState::handle_unsafe_access_error() {
     // back to Java until resumed we cannot create the exception
     // object yet. Add a new unsafe access error operation to
     // the end of the queue and try again in the next attempt.
-    Handshake::execute(new UnsafeAccessErrorHandshake(), _handshakee);
+    Handshake::execute(new UnsafeAccessErrorHandshakeClosure(), _handshakee);
     log_info(handshake)("JavaThread " INTPTR_FORMAT " skipping unsafe access processing due to suspend.", p2i(_handshakee));
     return;
   }
diff --git a/src/hotspot/share/runtime/handshake.hpp b/src/hotspot/share/runtime/handshake.hpp
index ca9cef76f5db8..c6f3aad08db19 100644
--- a/src/hotspot/share/runtime/handshake.hpp
+++ b/src/hotspot/share/runtime/handshake.hpp
@@ -35,7 +35,7 @@
 class HandshakeOperation;
 class AsyncHandshakeOperation;
 class JavaThread;
-class UnsafeAccessErrorHandshake;
+class UnsafeAccessErrorHandshakeClosure;
 class ThreadsListHandle;
 
 // A handshake closure is a callback that is executed for a JavaThread
@@ -86,7 +86,7 @@ class JvmtiRawMonitor;
 // operation is only done by either VMThread/Handshaker on behalf of the
 // JavaThread or by the target JavaThread itself.
 class HandshakeState {
-  friend UnsafeAccessErrorHandshake;
+  friend UnsafeAccessErrorHandshakeClosure;
   friend JavaThread;
   // This a back reference to the JavaThread,
   // the target for all operation in the queue.
diff --git a/src/hotspot/share/runtime/javaThread.cpp b/src/hotspot/share/runtime/javaThread.cpp
index abae0e10b3716..b84cf6e901113 100644
--- a/src/hotspot/share/runtime/javaThread.cpp
+++ b/src/hotspot/share/runtime/javaThread.cpp
@@ -1124,16 +1124,16 @@ void JavaThread::handle_async_exception(oop java_throwable) {
   }
 }
 
-void JavaThread::install_async_exception(AsyncExceptionHandshake* aeh) {
+void JavaThread::install_async_exception(AsyncExceptionHandshakeClosure* aehc) {
   // Do not throw asynchronous exceptions against the compiler thread
   // or if the thread is already exiting.
   if (!can_call_java() || is_exiting()) {
-    delete aeh;
+    delete aehc;
     return;
   }
 
-  oop exception = aeh->exception();
-  Handshake::execute(aeh, this);  // Install asynchronous handshake
+  oop exception = aehc->exception();
+  Handshake::execute(aehc, this);  // Install asynchronous handshake
 
   ResourceMark rm;
   if (log_is_enabled(Info, exceptions)) {
@@ -1151,25 +1151,25 @@ void JavaThread::install_async_exception(AsyncExceptionHandshake* aeh) {
   }
 }
 
-class InstallAsyncExceptionHandshake : public HandshakeClosure {
-  AsyncExceptionHandshake* _aeh;
+class InstallAsyncExceptionHandshakeClosure : public HandshakeClosure {
+  AsyncExceptionHandshakeClosure* _aehc;
 public:
-  InstallAsyncExceptionHandshake(AsyncExceptionHandshake* aeh) :
-    HandshakeClosure("InstallAsyncException"), _aeh(aeh) {}
-  ~InstallAsyncExceptionHandshake() {
-    // If InstallAsyncExceptionHandshake was never executed we need to clean up _aeh.
-    delete _aeh;
+  InstallAsyncExceptionHandshakeClosure(AsyncExceptionHandshakeClosure* aehc) :
+    HandshakeClosure("InstallAsyncException"), _aehc(aehc) {}
+  ~InstallAsyncExceptionHandshakeClosure() {
+    // If InstallAsyncExceptionHandshakeClosure was never executed we need to clean up _aehc.
+    delete _aehc;
   }
   void do_thread(Thread* thr) {
     JavaThread* target = JavaThread::cast(thr);
-    target->install_async_exception(_aeh);
-    _aeh = nullptr;
+    target->install_async_exception(_aehc);
+    _aehc = nullptr;
   }
 };
 
 void JavaThread::send_async_exception(JavaThread* target, oop java_throwable) {
   OopHandle e(Universe::vm_global(), java_throwable);
-  InstallAsyncExceptionHandshake iaeh(new AsyncExceptionHandshake(e));
+  InstallAsyncExceptionHandshakeClosure iaeh(new AsyncExceptionHandshakeClosure(e));
   Handshake::execute(&iaeh, target);
 }
 
diff --git a/src/hotspot/share/runtime/javaThread.hpp b/src/hotspot/share/runtime/javaThread.hpp
index af46492622d5d..fac263d904818 100644
--- a/src/hotspot/share/runtime/javaThread.hpp
+++ b/src/hotspot/share/runtime/javaThread.hpp
@@ -53,7 +53,7 @@
 #include "utilities/ticks.hpp"
 #endif
 
-class AsyncExceptionHandshake;
+class AsyncExceptionHandshakeClosure;
 class DeoptResourceMark;
 class InternalOOMEMark;
 class JNIHandleBlock;
@@ -233,13 +233,13 @@ class JavaThread: public Thread {
 
   // Asynchronous exception support
  private:
-  friend class InstallAsyncExceptionHandshake;
-  friend class AsyncExceptionHandshake;
+  friend class InstallAsyncExceptionHandshakeClosure;
+  friend class AsyncExceptionHandshakeClosure;
   friend class HandshakeState;
 
   void handle_async_exception(oop java_throwable);
  public:
-  void install_async_exception(AsyncExceptionHandshake* aec = nullptr);
+  void install_async_exception(AsyncExceptionHandshakeClosure* aec = nullptr);
   bool has_async_exception_condition();
   inline void set_pending_unsafe_access_error();
   static void send_async_exception(JavaThread* jt, oop java_throwable);
@@ -1164,7 +1164,7 @@ class JavaThread: public Thread {
   // Used by the interpreter in fullspeed mode for frame pop, method
   // entry, method exit and single stepping support. This field is
   // only set to non-zero at a safepoint or using a direct handshake
-  // (see EnterInterpOnlyModeClosure).
+  // (see EnterInterpOnlyModeHandshakeClosure).
   // It can be set to zero asynchronously to this threads execution (i.e., without
   // safepoint/handshake or a lock) so we have to be very careful.
   // Accesses by other threads are synchronized using JvmtiThreadState_lock though.
diff --git a/src/hotspot/share/runtime/javaThread.inline.hpp b/src/hotspot/share/runtime/javaThread.inline.hpp
index 136a9d841519f..be76407f511da 100644
--- a/src/hotspot/share/runtime/javaThread.inline.hpp
+++ b/src/hotspot/share/runtime/javaThread.inline.hpp
@@ -73,13 +73,13 @@ inline bool JavaThread::clear_carrier_thread_suspended() {
 }
 #endif
 
-class AsyncExceptionHandshake : public AsyncHandshakeClosure {
+class AsyncExceptionHandshakeClosure : public AsyncHandshakeClosure {
   OopHandle _exception;
  public:
-  AsyncExceptionHandshake(OopHandle& o, const char* name = "AsyncExceptionHandshake")
+  AsyncExceptionHandshakeClosure(OopHandle& o, const char* name = "AsyncExceptionHandshakeClosure")
   : AsyncHandshakeClosure(name), _exception(o) { }
 
-  ~AsyncExceptionHandshake() {
+  ~AsyncExceptionHandshakeClosure() {
     Thread* current = Thread::current();
     // Can get here from the VMThread via install_async_exception() bail out.
     if (current->is_Java_thread()) {
@@ -103,9 +103,9 @@ class AsyncExceptionHandshake : public AsyncHandshakeClosure {
   bool is_async_exception()   { return true; }
 };
 
-class UnsafeAccessErrorHandshake : public AsyncHandshakeClosure {
+class UnsafeAccessErrorHandshakeClosure : public AsyncHandshakeClosure {
  public:
-  UnsafeAccessErrorHandshake() : AsyncHandshakeClosure("UnsafeAccessErrorHandshake") {}
+  UnsafeAccessErrorHandshakeClosure() : AsyncHandshakeClosure("UnsafeAccessErrorHandshakeClosure") {}
   void do_thread(Thread* thr) {
     JavaThread* self = JavaThread::cast(thr);
     assert(self == JavaThread::current(), "must be");
@@ -117,7 +117,7 @@ class UnsafeAccessErrorHandshake : public AsyncHandshakeClosure {
 
 inline void JavaThread::set_pending_unsafe_access_error() {
   if (!has_async_exception_condition()) {
-    Handshake::execute(new UnsafeAccessErrorHandshake(), this);
+    Handshake::execute(new UnsafeAccessErrorHandshakeClosure(), this);
   }
 }
 
diff --git a/src/hotspot/share/runtime/suspendResumeManager.cpp b/src/hotspot/share/runtime/suspendResumeManager.cpp
index fd14f73f553cf..2e75d763cb390 100644
--- a/src/hotspot/share/runtime/suspendResumeManager.cpp
+++ b/src/hotspot/share/runtime/suspendResumeManager.cpp
@@ -35,9 +35,9 @@
 
 // This is the closure that prevents a suspended JavaThread from
 // escaping the suspend request.
-class ThreadSelfSuspensionHandshake : public AsyncHandshakeClosure {
+class ThreadSelfSuspensionHandshakeClosure : public AsyncHandshakeClosure {
 public:
-  ThreadSelfSuspensionHandshake() : AsyncHandshakeClosure("ThreadSelfSuspensionHandshake") {}
+  ThreadSelfSuspensionHandshakeClosure() : AsyncHandshakeClosure("ThreadSelfSuspensionHandshakeClosure") {}
   void do_thread(Thread* thr) {
     JavaThread* current = JavaThread::cast(thr);
     assert(current == Thread::current(), "Must be self executed.");
@@ -52,11 +52,11 @@ class ThreadSelfSuspensionHandshake : public AsyncHandshakeClosure {
 };
 
 // This is the closure that synchronously honors the suspend request.
-class SuspendThreadHandshake : public HandshakeClosure {
+class SuspendThreadHandshakeClosure : public HandshakeClosure {
   bool _register_vthread_SR;
   bool _did_suspend;
 public:
-  SuspendThreadHandshake(bool register_vthread_SR) : HandshakeClosure("SuspendThread"),
+  SuspendThreadHandshakeClosure(bool register_vthread_SR) : HandshakeClosure("SuspendThread"),
     _register_vthread_SR(register_vthread_SR), _did_suspend(false) {
   }
   void do_thread(Thread* thr) {
@@ -93,7 +93,7 @@ bool SuspendResumeManager::suspend(bool register_vthread_SR) {
     do_owner_suspend();
     return true;
   } else {
-    SuspendThreadHandshake st(register_vthread_SR);
+    SuspendThreadHandshakeClosure st(register_vthread_SR);
     Handshake::execute(&st, _target);
     return st.did_suspend();
   }
@@ -150,7 +150,7 @@ bool SuspendResumeManager::suspend_with_handshake(bool register_vthread_SR) {
   set_suspended(true, register_vthread_SR);
   set_async_suspend_handshake(true);
   log_trace(thread, suspend)("JavaThread:" INTPTR_FORMAT " suspended, arming ThreadSuspension", p2i(_target));
-  ThreadSelfSuspensionHandshake* ts = new ThreadSelfSuspensionHandshake();
+  ThreadSelfSuspensionHandshakeClosure* ts = new ThreadSelfSuspensionHandshakeClosure();
   Handshake::execute(ts, _target);
   return true;
 }
diff --git a/src/hotspot/share/runtime/suspendResumeManager.hpp b/src/hotspot/share/runtime/suspendResumeManager.hpp
index fed3b34055e8b..01735cb3bf8e9 100644
--- a/src/hotspot/share/runtime/suspendResumeManager.hpp
+++ b/src/hotspot/share/runtime/suspendResumeManager.hpp
@@ -25,12 +25,12 @@
 #ifndef SHARE_RUNTIME_SUSPENDRESUMEMANAGER_HPP
 #define SHARE_RUNTIME_SUSPENDRESUMEMANAGER_HPP
 
-class SuspendThreadHandshake;
-class ThreadSelfSuspensionHandshake;
+class SuspendThreadHandshakeClosure;
+class ThreadSelfSuspensionHandshakeClosure;
 
 class SuspendResumeManager {
-  friend SuspendThreadHandshake;
-  friend ThreadSelfSuspensionHandshake;
+  friend SuspendThreadHandshakeClosure;
+  friend ThreadSelfSuspensionHandshakeClosure;
   friend JavaThread;
 
   JavaThread* _target;
diff --git a/src/hotspot/share/runtime/synchronizer.cpp b/src/hotspot/share/runtime/synchronizer.cpp
index 503b783335175..221e7dd71ecbe 100644
--- a/src/hotspot/share/runtime/synchronizer.cpp
+++ b/src/hotspot/share/runtime/synchronizer.cpp
@@ -1664,12 +1664,12 @@ size_t ObjectSynchronizer::deflate_monitor_list(ObjectMonitorDeflationSafepointe
   return deflated_count;
 }
 
-class HandshakeForDeflation : public HandshakeClosure {
+class DeflationHandshakeClosure : public HandshakeClosure {
  public:
-  HandshakeForDeflation() : HandshakeClosure("HandshakeForDeflation") {}
+  DeflationHandshakeClosure() : HandshakeClosure("DeflationHandshakeClosure") {}
 
   void do_thread(Thread* thread) {
-    log_trace(monitorinflation)("HandshakeForDeflation::do_thread: thread="
+    log_trace(monitorinflation)("DeflationHandshakeClosure::do_thread: thread="
                                 INTPTR_FORMAT, p2i(thread));
     if (thread->is_Java_thread()) {
       // Clear OM cache
@@ -1834,8 +1834,8 @@ size_t ObjectSynchronizer::deflate_idle_monitors() {
 
     // A JavaThread needs to handshake in order to safely free the
     // ObjectMonitors that were deflated in this cycle.
-    HandshakeForDeflation hfd_hc;
-    Handshake::execute(&hfd_hc);
+    DeflationHandshakeClosure dhc;
+    Handshake::execute(&dhc);
     // Also, we sync and desync GC threads around the handshake, so that they can
     // safely read the mark-word and look-through to the object-monitor, without
     // being afraid that the object-monitor is going away.
diff --git a/src/hotspot/share/runtime/vmThread.cpp b/src/hotspot/share/runtime/vmThread.cpp
index 0ff5e5d227b5b..2a31929c34bb7 100644
--- a/src/hotspot/share/runtime/vmThread.cpp
+++ b/src/hotspot/share/runtime/vmThread.cpp
@@ -297,9 +297,9 @@ void VMThread::evaluate_operation(VM_Operation* op) {
   }
 }
 
-class HandshakeALotClosure : public HandshakeClosure {
+class ALotOfHandshakeClosure : public HandshakeClosure {
  public:
-  HandshakeALotClosure() : HandshakeClosure("HandshakeALot") {}
+  ALotOfHandshakeClosure() : HandshakeClosure("ALotOfHandshakeClosure") {}
   void do_thread(Thread* thread) {
 #ifdef ASSERT
     JavaThread::cast(thread)->verify_states_for_handshake();
@@ -453,8 +453,8 @@ void VMThread::wait_for_operation() {
     if (handshake_or_safepoint_alot()) {
       if (HandshakeALot) {
         MutexUnlocker mul(VMOperation_lock);
-        HandshakeALotClosure hal_cl;
-        Handshake::execute(&hal_cl);
+        ALotOfHandshakeClosure aohc;
+        Handshake::execute(&aohc);
       }
       // When we unlocked above someone might have setup a new op.
       if (_next_vm_operation != nullptr) {
diff --git a/src/hotspot/share/services/threadService.cpp b/src/hotspot/share/services/threadService.cpp
index 8e0c955bff8a8..244fd9bacbf6f 100644
--- a/src/hotspot/share/services/threadService.cpp
+++ b/src/hotspot/share/services/threadService.cpp
@@ -1124,7 +1124,7 @@ ThreadsListEnumerator::ThreadsListEnumerator(Thread* cur_thread,
 // jdk.internal.vm.ThreadSnapshot support
 #if INCLUDE_JVMTI
 
-class GetThreadSnapshotClosure: public HandshakeClosure {
+class GetThreadSnapshotHandshakeClosure: public HandshakeClosure {
 private:
   static OopStorage* oop_storage() {
     assert(_thread_service_storage != nullptr, "sanity");
@@ -1180,14 +1180,14 @@ class GetThreadSnapshotClosure: public HandshakeClosure {
   GrowableArray<OwnedLock>* _locks;
   Blocker _blocker;
 
-  GetThreadSnapshotClosure(Handle thread_h, JavaThread* java_thread):
-    HandshakeClosure("GetThreadSnapshotClosure"),
+  GetThreadSnapshotHandshakeClosure(Handle thread_h, JavaThread* java_thread):
+    HandshakeClosure("GetThreadSnapshotHandshakeClosure"),
     _thread_h(thread_h), _java_thread(java_thread),
     _frame_count(0), _methods(nullptr), _bcis(nullptr),
     _thread_status(), _thread_name(nullptr),
     _locks(nullptr), _blocker() {
   }
-  virtual ~GetThreadSnapshotClosure() {
+  virtual ~GetThreadSnapshotHandshakeClosure() {
     delete _methods;
     delete _bcis;
     _thread_name.release(oop_storage());
@@ -1476,7 +1476,7 @@ oop ThreadSnapshotFactory::get_thread_snapshot(jobject jthread, TRAPS) {
   }
 
   // Handshake with target
-  GetThreadSnapshotClosure cl(thread_h, java_thread);
+  GetThreadSnapshotHandshakeClosure cl(thread_h, java_thread);
   if (java_thread == nullptr) {
     // unmounted vthread, execute on the current thread
     cl.do_thread(nullptr);
@@ -1508,7 +1508,7 @@ oop ThreadSnapshotFactory::get_thread_snapshot(jobject jthread, TRAPS) {
   if (cl._locks != nullptr && cl._locks->length() > 0) {
     locks = oopFactory::new_objArray_handle(lock_klass, cl._locks->length(), CHECK_NULL);
     for (int n = 0; n < cl._locks->length(); n++) {
-      GetThreadSnapshotClosure::OwnedLock* lock_info = cl._locks->adr_at(n);
+      GetThreadSnapshotHandshakeClosure::OwnedLock* lock_info = cl._locks->adr_at(n);
 
       Handle lock = jdk_internal_vm_ThreadLock::create(lock_klass,
         lock_info->_frame_depth, lock_info->_type, lock_info->_obj, CHECK_NULL);