< prev index next >

src/hotspot/share/runtime/handshake.cpp

Print this page
rev 57156 : imported patch 8234796-v3

@@ -43,14 +43,14 @@
   virtual void do_handshake(JavaThread* thread) = 0;
 };
 
 class HandshakeThreadsOperation: public HandshakeOperation {
   static Semaphore _done;
-  ThreadClosure* _thread_cl;
+  HandshakeClosure* _handshake_cl;
   bool _executed;
 public:
-  HandshakeThreadsOperation(ThreadClosure* cl) : _thread_cl(cl), _executed(false) {}
+  HandshakeThreadsOperation(HandshakeClosure* cl) : _handshake_cl(cl), _executed(false) {}
   void do_handshake(JavaThread* thread);
   bool thread_has_completed() { return _done.trywait(); }
   bool executed() const { return _executed; }
 
 #ifdef ASSERT

@@ -204,28 +204,28 @@
 
   VMOp_Type type() const { return VMOp_HandshakeAllThreads; }
 };
 
 class VM_HandshakeFallbackOperation : public VM_Operation {
-  ThreadClosure* _thread_cl;
+  HandshakeClosure* _handshake_cl;
   Thread* _target_thread;
   bool _all_threads;
   bool _executed;
 public:
-  VM_HandshakeFallbackOperation(ThreadClosure* cl) :
-      _thread_cl(cl), _target_thread(NULL), _all_threads(true), _executed(false) {}
-  VM_HandshakeFallbackOperation(ThreadClosure* cl, Thread* target) :
-      _thread_cl(cl), _target_thread(target), _all_threads(false), _executed(false) {}
+  VM_HandshakeFallbackOperation(HandshakeClosure* cl) :
+      _handshake_cl(cl), _target_thread(NULL), _all_threads(true), _executed(false) {}
+  VM_HandshakeFallbackOperation(HandshakeClosure* cl, Thread* target) :
+      _handshake_cl(cl), _target_thread(target), _all_threads(false), _executed(false) {}
 
   void doit() {
     log_trace(handshake)("VMThread executing VM_HandshakeFallbackOperation");
     for (JavaThreadIteratorWithHandle jtiwh; JavaThread *t = jtiwh.next(); ) {
       if (_all_threads || t == _target_thread) {
         if (t == _target_thread) {
           _executed = true;
         }
-        _thread_cl->do_thread(t);
+        _handshake_cl->do_thread(t);
       }
     }
   }
 
   VMOp_Type type() const { return VMOp_HandshakeFallback; }

@@ -238,30 +238,30 @@
                                p2i(thread), BOOL_TO_STR(Thread::current()->is_VM_thread()));
   TraceTime timer(message, TRACETIME_LOG(Debug, handshake, task));
 
   // Only actually execute the operation for non terminated threads.
   if (!thread->is_terminated()) {
-    _thread_cl->do_thread(thread);
+    _handshake_cl->do_thread(thread);
     _executed = true;
   }
 
   // Use the semaphore to inform the VM thread that we have completed the operation
   _done.signal();
 }
 
-void Handshake::execute(ThreadClosure* thread_cl) {
+void Handshake::execute(HandshakeClosure* thread_cl) {
   if (ThreadLocalHandshakes) {
     HandshakeThreadsOperation cto(thread_cl);
     VM_HandshakeAllThreads handshake(&cto);
     VMThread::execute(&handshake);
   } else {
     VM_HandshakeFallbackOperation op(thread_cl);
     VMThread::execute(&op);
   }
 }
 
-bool Handshake::execute(ThreadClosure* thread_cl, JavaThread* target) {
+bool Handshake::execute(HandshakeClosure* thread_cl, JavaThread* target) {
   if (ThreadLocalHandshakes) {
     HandshakeThreadsOperation cto(thread_cl);
     VM_HandshakeOneThread handshake(&cto, target);
     VMThread::execute(&handshake);
     return handshake.executed();
< prev index next >