Java Unsafe-park/unpark操作

park/unpark操作

这两个操作通常配合在一起使用，park操作用于阻塞当前线程，unpark用于使阻塞在park操作代码处的线程退出阻塞。

 

park操作

 

Block current thread, returning when a balancing

<tt>unpark</tt> occurs, or a balancing <tt>unpark</tt> has

already occurred, or the thread is interrupted, or, if not

absolute and time is not zero, the given time nanoseconds have

elapsed, or if absolute, the given deadline in milliseconds

since Epoch has passed, or spuriously (i.e., returning for no

"reason"). Note: This operation is in the Unsafe class only

because <tt>unpark</tt> is, so it would be strange to place it

elsewhere.

 

该方法是一个native方法：

public native void park(boolean isAbsolute, long time);

该方法实现unsafe.cpp在\hotspot\src\share\vm\prims目录下。

UNSAFE_ENTRY(void, Unsafe_Park(JNIEnv *env, jobject unsafe, jboolean isAbsolute, jlong time))

  UnsafeWrapper("Unsafe_Park");

#ifndef USDT2

  HS_DTRACE_PROBE3(hotspot, thread__park__begin, thread->parker(), (int) isAbsolute, time);

#else /* USDT2 */

   HOTSPOT_THREAD_PARK_BEGIN(

                             (uintptr_t) thread->parker(), (int) isAbsolute, time);

#endif /* USDT2 */

  JavaThreadParkedState jtps(thread, time != 0);

  thread->parker()->park(isAbsolute != 0, time);

#ifndef USDT2

  HS_DTRACE_PROBE1(hotspot, thread__park__end, thread->parker());

#else /* USDT2 */

  HOTSPOT_THREAD_PARK_END(

                          (uintptr_t) thread->parker());

#endif /* USDT2 */

UNSAFE_END

以上代码需要展开来才能看得懂，展开后代码如下：

如果定义了USDT2宏

UNSAFE_ENTRY(void, Unsafe_Park(JNIEnv *env, jobject unsafe, jboolean isAbsolute, jlong time))
  UnsafeWrapper("Unsafe_Park");
  HOTSPOT_THREAD_PARK_BEGIN(
                             (uintptr_t) thread->parker(), (int) isAbsolute, time);
  JavaThreadParkedState jtps(thread, time != 0);
  thread->parker()->park(isAbsolute != 0, time);
  HOTSPOT_THREAD_PARK_END(
                          (uintptr_t) thread->parker());
UNSAFE_END

 

#define HOTSPOT_THREAD_PARK_BEGIN(arg0, arg1, arg2)

 

#define HOTSPOT_THREAD_PARK_END(arg0)

 

 

extern "C" {                                                        

  void JNICALL Unsafe_Park(JNIEnv *env, jobject unsafe, jboolean isAbsolute, jlong time) {                                      

    JavaThread* thread=JavaThread::thread_from_jni_environment(env);

    ThreadInVMfromNative __tiv(thread);

 

    /* do nothing */

 

    HandleMarkCleaner __hm(thread);                                   

    Thread* THREAD = thread;

 

    /* begin of body */

 

    /*nothing, for the present*/;

 

    ;

    JavaThreadParkedState jtps(thread, time != 0);

    thread->parker()->park(isAbsolute != 0, time);

    ;

  }

}

 

如果没有定义USDT2宏

UNSAFE_ENTRY(void, Unsafe_Park(JNIEnv *env, jobject unsafe, jboolean isAbsolute, jlong time))
  UnsafeWrapper("Unsafe_Park");
  HS_DTRACE_PROBE3(hotspot, thread__park__begin, thread->parker(), (int) isAbsolute, time);
  JavaThreadParkedState jtps(thread, time != 0);
  thread->parker()->park(isAbsolute != 0, time);
  HOTSPOT_THREAD_PARK_END(
                          (uintptr_t) thread->parker());
UNSAFE_END

 

 

这里不展开USDT2宏没有定义的那段代码

 

其中主要的代码在：

thread->parker()->park(isAbsolute != 0, time);

 

solaris平台下这块代码实现在os_solaris.cpp，在\hotspot\src\os\solaris\vm目录下。

void Parker::park(bool isAbsolute, jlong time) {

 

  // Optional fast-path check:

  // Return immediately if a permit is available.

  if (_counter > 0) {

      _counter = 0 ;

      OrderAccess::fence();

      return ;

  }

 

  // Optional fast-exit: Check interrupt before trying to wait

  Thread* thread = Thread::current();

  assert(thread->is_Java_thread(), "Must be JavaThread");

  JavaThread *jt = (JavaThread *)thread;

  if (Thread::is_interrupted(thread, false)) {

    return;

  }

 

  // First, demultiplex/decode time arguments

  timespec absTime;

  if (time < 0 || (isAbsolute && time == 0) ) { // don't wait at all

    return;

  }

  if (time > 0) {

    // Warning: this code might be exposed to the old Solaris time

    // round-down bugs.  Grep "roundingFix" for details.

    unpackTime(&absTime, isAbsolute, time);

  }

 

  // Enter safepoint region

  // Beware of deadlocks such as 6317397.

  // The per-thread Parker:: _mutex is a classic leaf-lock.

  // In particular a thread must never block on the Threads_lock while

  // holding the Parker:: mutex.  If safepoints are pending both the

  // the ThreadBlockInVM() CTOR and DTOR may grab Threads_lock.

  ThreadBlockInVM tbivm(jt);

 

  // Don't wait if cannot get lock since interference arises from

  // unblocking.  Also. check interrupt before trying wait

  if (Thread::is_interrupted(thread, false) ||

      os::Solaris::mutex_trylock(_mutex) != 0) {

    return;

  }

 

  int status ;

 

  if (_counter > 0)  { // no wait needed

    _counter = 0;

    status = os::Solaris::mutex_unlock(_mutex);

    assert (status == 0, "invariant") ;

    OrderAccess::fence();

    return;

  }

 

#ifdef ASSERT

  // Don't catch signals while blocked; let the running threads have the signals.

  // (This allows a debugger to break into the running thread.)

  sigset_t oldsigs;

  sigset_t* allowdebug_blocked = os::Solaris::allowdebug_blocked_signals();

  thr_sigsetmask(SIG_BLOCK, allowdebug_blocked, &oldsigs);

#endif

 

  OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);

  jt->set_suspend_equivalent();

  // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()

 

  // Do this the hard way by blocking ...

  // See http://monaco.sfbay/detail.jsf?cr=5094058.

  // TODO-FIXME: for Solaris SPARC set fprs.FEF=0 prior to parking.

  // Only for SPARC >= V8PlusA

#if defined(__sparc) && defined(COMPILER2)

  if (ClearFPUAtPark) { _mark_fpu_nosave() ; }

#endif

 

  if (time == 0) {

    status = os::Solaris::cond_wait (_cond, _mutex) ;

  } else {

    status = os::Solaris::cond_timedwait (_cond, _mutex, &absTime);

  }

  // Note that an untimed cond_wait() can sometimes return ETIME on older

  // versions of the Solaris.

  assert_status(status == 0 || status == EINTR ||

                status == ETIME || status == ETIMEDOUT,

                status, "cond_timedwait");

 

#ifdef ASSERT

  thr_sigsetmask(SIG_SETMASK, &oldsigs, NULL);

#endif

  _counter = 0 ;

  status = os::Solaris::mutex_unlock(_mutex);

  assert_status(status == 0, status, "mutex_unlock") ;

 

  // If externally suspended while waiting, re-suspend

  if (jt->handle_special_suspend_equivalent_condition()) {

    jt->java_suspend_self();

  }

  OrderAccess::fence();

}

 

 

 

linux平台下这块代码实现在os_linux.cpp，在hotspot\src\os\linux\vm目录下。

void Parker::park(bool isAbsolute, jlong time) {
  // Optional fast-path check:
  // Return immediately if a permit is available.
  if (_counter > 0) {
      _counter = 0 ;
      OrderAccess::fence();
      return ;
  }

  Thread* thread = Thread::current();
  assert(thread->is_Java_thread(), "Must be JavaThread");
  JavaThread *jt = (JavaThread *)thread;

  // Optional optimization -- avoid state transitions if there's an interrupt pending.
  // Check interrupt before trying to wait
  if (Thread::is_interrupted(thread, false)) {
    return;
  }

  // Next, demultiplex/decode time arguments
  timespec absTime;
  if (time < 0 || (isAbsolute && time == 0) ) { // don't wait at all
    return;
  }
  if (time > 0) {
    unpackTime(&absTime, isAbsolute, time);
  }


  // Enter safepoint region
  // Beware of deadlocks such as 6317397.
  // The per-thread Parker:: mutex is a classic leaf-lock.
  // In particular a thread must never block on the Threads_lock while
  // holding the Parker:: mutex.  If safepoints are pending both the
  // the ThreadBlockInVM() CTOR and DTOR may grab Threads_lock.
  ThreadBlockInVM tbivm(jt);

  // Don't wait if cannot get lock since interference arises from
  // unblocking.  Also. check interrupt before trying wait
  if (Thread::is_interrupted(thread, false) || pthread_mutex_trylock(_mutex) != 0) {
    return;
  }

  int status ;
  if (_counter > 0)  { // no wait needed
    _counter = 0;
    status = pthread_mutex_unlock(_mutex);
    assert (status == 0, "invariant") ;
    OrderAccess::fence();
    return;
  }

#ifdef ASSERT
  // Don't catch signals while blocked; let the running threads have the signals.
  // (This allows a debugger to break into the running thread.)
  sigset_t oldsigs;
  sigset_t* allowdebug_blocked = os::Linux::allowdebug_blocked_signals();
  pthread_sigmask(SIG_BLOCK, allowdebug_blocked, &oldsigs);
#endif

  OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
  jt->set_suspend_equivalent();
  // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()

  if (time == 0) {
    status = pthread_cond_wait (_cond, _mutex) ;
  } else {
    status = os::Linux::safe_cond_timedwait (_cond, _mutex, &absTime) ;
    if (status != 0 && WorkAroundNPTLTimedWaitHang) {
      pthread_cond_destroy (_cond) ;
      pthread_cond_init    (_cond, NULL);
    }
  }
  assert_status(status == 0 || status == EINTR ||
                status == ETIME || status == ETIMEDOUT,
                status, "cond_timedwait");

#ifdef ASSERT
  pthread_sigmask(SIG_SETMASK, &oldsigs, NULL);
#endif

  _counter = 0 ;
  status = pthread_mutex_unlock(_mutex) ;
  assert_status(status == 0, status, "invariant") ;
  // If externally suspended while waiting, re-suspend
  if (jt->handle_special_suspend_equivalent_condition()) {
    jt->java_suspend_self();
  }

  OrderAccess::fence();
}

 

 

 

UNSAFE_ENTRY定义：

#define UNSAFE_ENTRY(result_type, header) \
  JVM_ENTRY(result_type, header)

 

 

UNSAFE_END定义：

 

#define UNSAFE_END JVM_END

  

 

  

 

JVM_ENTRY定义：

#define JVM_ENTRY(result_type, header)                               \
extern "C" {                                                         \
  result_type JNICALL header {                                       \
    JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
    ThreadInVMfromNative __tiv(thread);                              \
    debug_only(VMNativeEntryWrapper __vew;)                          \
    VM_ENTRY_BASE(result_type, header, thread)

 

 

#define VM_ENTRY_BASE(result_type, header, thread)                   \
  TRACE_CALL(result_type, header)                                    \
  HandleMarkCleaner __hm(thread);                                    \
  Thread* THREAD = thread;                                           \
  /* begin of body */

 

JVM_END定义：

#define JVM_END } }

 

所以，UNSAFE_ENTRY(void, Unsafe_Park(JNIEnv *env, jobject unsafe, jboolean isAbsolute, jlong time))展开后的代码：

extern "C" {                                                           
  void JNICALL Unsafe_Park(JNIEnv *env, jobject unsafe, jboolean isAbsolute, jlong time)) {                                         
    JavaThread* thread=JavaThread::thread_from_jni_environment(env); 
    ThreadInVMfromNative __tiv(thread);                              
    debug_only(VMNativeEntryWrapper __vew;)                          
    VM_ENTRY_BASE(result_type, header, thread)  

 

 

UnsafeWrapper定义：

#define UnsafeWrapper(arg) /*nothing, for the present*/

 

 

 

park/unpark操作

 

这两个操作通常配合在一起使用，park操作用于阻塞当前线程，unpark用于使阻塞在park操作代码处的线程退出阻塞。

 

 

unpark操作

该方法是一个native方法：

public native void unpark(Object thread);

该方法实现unsafe.cpp在\hotspot\src\share\vm\prims目录下。

UNSAFE_ENTRY(void, Unsafe_Unpark(JNIEnv *env, jobject unsafe, jobject jthread))

  UnsafeWrapper("Unsafe_Unpark");

  Parker* p = NULL;

  if (jthread != NULL) {

    oop java_thread = JNIHandles::resolve_non_null(jthread);

    if (java_thread != NULL) {

      jlong lp = java_lang_Thread::park_event(java_thread);

      if (lp != 0) {

        // This cast is OK even though the jlong might have been read

        // non-atomically on 32bit systems, since there, one word will

        // always be zero anyway and the value set is always the same

        p = (Parker*)addr_from_java(lp);

      } else {

        // Grab lock if apparently null or using older version of library

        MutexLocker mu(Threads_lock);

        java_thread = JNIHandles::resolve_non_null(jthread);

        if (java_thread != NULL) {

          JavaThread* thr = java_lang_Thread::thread(java_thread);

          if (thr != NULL) {

            p = thr->parker();

            if (p != NULL) { // Bind to Java thread for next time.

              java_lang_Thread::set_park_event(java_thread, addr_to_java(p));

            }

          }

        }

      }

    }

  }

  if (p != NULL) {

#ifndef USDT2

    HS_DTRACE_PROBE1(hotspot, thread__unpark, p);

#else /* USDT2 */

    HOTSPOT_THREAD_UNPARK(

                          (uintptr_t) p);

#endif /* USDT2 */

    p->unpark();

  }

UNSAFE_END

以上代码需要展开来才能看得懂，展开后代码如下：

如果定义了USDT2宏

extern "C" {

  void JNICALL Unsafe_Unpark(JNIEnv *env, jobject unsafe, jobject jthread) {

    JavaThread* thread=JavaThread::thread_from_jni_environment(env);

    ThreadInVMfromNative __tiv(thread);

 

    /* do nothing */

 

    HandleMarkCleaner __hm(thread);

    Thread* THREAD = thread;

 

    /* begin of body */

 

    /*nothing, for the present*/;

 

    Parker* p = NULL;

    if (jthread != NULL) {

      oop java_thread = JNIHandles::resolve_non_null(jthread);

      if (java_thread != NULL) {

        jlong lp = java_lang_Thread::park_event(java_thread);

        if (lp != 0) {

          // This cast is OK even though the jlong might have been read

          // non-atomically on 32bit systems, since there, one word will

          // always be zero anyway and the value set is always the same

          p = (Parker*)addr_from_java(lp);

        } else {

          // Grab lock if apparently null or using older version of library

          MutexLocker mu(Threads_lock);

          java_thread = JNIHandles::resolve_non_null(jthread);

          if (java_thread != NULL) {

            JavaThread* thr = java_lang_Thread::thread(java_thread);

            if (thr != NULL) {

              p = thr->parker();

              if (p != NULL) { // Bind to Java thread for next time.

                java_lang_Thread::set_park_event(java_thread, addr_to_java(p));

              }

            }

          }

        }

      }

    }

    if (p != NULL) {

      ;

      p->unpark();

    }

  }

}

 

如果没有定义USDT2宏

这里不展开USDT2宏没有定义的那段代码

 

其中主要的代码在：

p->unpark();

 

这块代码实现在os_solaris.cpp，在\hotspot\src\os\solaris\vm目录下。

void Parker::unpark() {

  int s, status ;

  status = os::Solaris::mutex_lock (_mutex) ;

  assert (status == 0, "invariant") ;

  s = _counter;

  _counter = 1;

  status = os::Solaris::mutex_unlock (_mutex) ;

  assert (status == 0, "invariant") ;

 

  if (s < 1) {

    status = os::Solaris::cond_signal (_cond) ;

    assert (status == 0, "invariant") ;

  }

}