JAVA ReentrantLock可見性?

// Optional fast-path check:
// Return immediately if a permit is available.
// We depend on Atomic::xchg() having full barrier semantics
// since we are doing a lock-free update to _counter.
if (Atomic::xchg(0, _counter) &> 0) 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
struct 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") ;
// Paranoia to ensure our locked and lock-free paths interact
// correctly with each other and Java-level accesses.
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::Bsd::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::Bsd::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 == 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") ;
// Paranoia to ensure our locked and lock-free paths interact
// correctly with each other and Java-level accesses.
OrderAccess::fence();

// If externally suspended while waiting, re-suspend
if (jt-&>handle_special_suspend_equivalent_condition()) {
jt-&>java_suspend_self();
}
}