java locksupport_Java LockSupport

LockSupport APIs

1. unpark(Thread thread)

Create a new thread to unpark thread t after seconds passed.

/**

* Create a new thread to unpark thread t after seconds passed

* @param t

* @param seconds

*/

private static void unpark(Thread t, long seconds) {

new Thread(() -> {

try {

Thread.sleep(seconds * _SEC_MS);

} catch (InterruptedException e) {

e.printStackTrace();

}

LockSupport.unpark(t);

}).start();

}

2. park() vs park(Object blocker)

t1 is blocked by LockSupport.park().

t2 is blocked by LockSupport.park(blocker).

unpark t1 and t2 after 60 seconds.

private static void parkVsParkBlocker() {

Thread t1 = new Thread(() -> {

LockSupport.park();

}, "t1");

t1.start();

Object blocker = new Object();

Thread t2 = new Thread(() -> {

LockSupport.park(blocker);

}, "t2");

t2.start();

LockSupport.getBlocker(t2);

unpark(t1, 60);

unpark(t2, 60);

}

Print java stack trace of a given jvm process.

jstack `jps -l | grep LockSupport | awk '{print $1}'`

park vs park with blocker

3. getBlocker(Thread t)

LockSupport.getBlocker(t2);

4. parkNanos(long nanos) vs parkUntil(long deadline)

Park thread t1, t2, t3, t4 for 5 seconds, unpark t2, t4 after 2 seconds.

Thread t1, t2 parkNanos(long nanos).

Thread t1 = park(5, 5, ParkMethod.PARK_NANOS);

Thread t2 = park(5, 2, ParkMethod.PARK_NANOS);

unpark(t2, 2);

Thread t3, t4 parkUntil(long deadline).

Thread t3 = park(5, 5, ParkMethod.PARK_UNTIL);

Thread t4 = park(5, 2, ParkMethod.PARK_UNTIL);

unpark(t4, 2);

Thread t1, t3 are blocked for 5 seconds, since no other thread unpark t1, t3.

Thread t2, t4 are blocked for 2 seconds, since other thread unpark t2, t4 after 2 seconds.

private static long _SEC_NS = 1000000000;

private static long _SEC_MS = 1000;

enum ParkMethod {

PARK_NANOS, PARK_UNTIL;

}

private static Thread park(long parkSeconds, long actualParkSeconds, ParkMethod parkMethod) {

Thread t = new Thread(() -> {

long start = System.currentTimeMillis();

switch (parkMethod) {

case PARK_NANOS:

LockSupport.parkNanos(parkSeconds * _SEC_NS);

break;

case PARK_UNTIL:

LockSupport.parkUntil(start + parkSeconds * _SEC_MS);

break;

default:

break;

}

assert (System.currentTimeMillis() - start) / _SEC_MS == actualParkSeconds;

});

t.start();

return t;

}

5. parkNanos(Object blocker, long nanos) vs parkUntil(Object blocker, long deadline)

Thread t1, t2 are blocked for object blocker for 60 seconds

private static void parkNanosVsParkUtilBlocker() {

Object blocker = new Object();

Thread t1 = new Thread(() -> {

LockSupport.parkNanos(blocker, 60 * _SEC_NS);

});

Thread t2 = new Thread(() -> {

LockSupport.parkUntil(blocker, System.currentTimeMillis() + 60 * _SEC_MS);

});

t1.start();

t2.start();

}

Source code

LockSupport

Delegation of method park() and unpark() in Unsafe.

private static final Unsafe U = Unsafe.getUnsafe();

public static void park() {

U.park(false, 0L);

}

public static void unpark(Thread thread) {

if (thread != null)

U.unpark(thread);

}

Unsafe

Call native method.

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

public native void unpark(Object thread);

park

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

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

EventThreadPark event;

JavaThreadParkedState jtps(thread, time != 0);

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

if (event.should_commit()) {

const oop obj = thread->current_park_blocker();

if (time == 0) {

post_thread_park_event(&event, obj, min_jlong, min_jlong);

} else {

if (isAbsolute != 0) {

post_thread_park_event(&event, obj, min_jlong, time);

} else {

post_thread_park_event(&event, obj, time, min_jlong);

}

}

}

HOTSPOT_THREAD_PARK_END((uintptr_t) thread->parker());

} UNSAFE_END

展开宏定义

extern "C" {

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

//UNSAFE_ENTRY JVM_ENTRY begin

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

ThreadInVMfromNative __tiv(thread);

debug_only(VMNativeEntryWrapper __vew;)

VM_ENTRY_BASE(result_type, header, thread)

//UNSAFE_ENTRY JVM_ENTRY end

{

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

EventThreadPark event;

JavaThreadParkedState jtps(thread, time != 0);

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

if (event.should_commit()) {

const oop obj = thread->current_park_blocker();

if (time == 0) {

post_thread_park_event(&event, obj, min_jlong, min_jlong);

} else {

if (isAbsolute != 0) {

post_thread_park_event(&event, obj, min_jlong, time);

} else {

post_thread_park_event(&event, obj, time, min_jlong);

}

}

}

//HOTSPOT_THREAD_PARK_END((uintptr_t) thread->parker());

}

}

}

Get thread object from jni environment

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

Create JavaThreadParkedState object

JavaThreadParkedState jtps(thread, time != 0);

save thread's old state

set thread's state to PARKED or PARKED_TIMED

Call park() on thread's _parker object

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

unpark

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

Parker* p = NULL;

if (jthread != NULL) {

ThreadsListHandle tlh;

JavaThread* thr = NULL;

oop java_thread = NULL;

(void) tlh.cv_internal_thread_to_JavaThread(jthread, &thr, &java_thread);

if (java_thread != NULL) {

// This is a valid oop.

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 {

// Not cached in the java.lang.Thread oop yet (could be an

// older version of library).

if (thr != NULL) {

// The JavaThread is alive.

p = thr->parker();

if (p != NULL) {

// Cache the Parker in the java.lang.Thread oop for next time.

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

}

}

}

}

} // ThreadsListHandle is destroyed here.

if (p != NULL) {

HOTSPOT_THREAD_UNPARK((uintptr_t) p);

p->unpark();

}

} UNSAFE_END

展开宏定义

extern "C" {

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

//UNSAFE_ENTRY JVM_ENTRY begin

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

ThreadInVMfromNative __tiv(thread);

debug_only(VMNativeEntryWrapper __vew;)

VM_ENTRY_BASE(result_type, header, thread)

//UNSAFE_ENTRY JVM_ENTRY end

{

Parker *p = NULL;

if (jthread != NULL) {

ThreadsListHandle tlh;

JavaThread *thr = NULL;

oop java_thread = NULL;

(void)tlh.cv_internal_thread_to_JavaThread(jthread, &thr, &java_thread);

if (java_thread != NULL) {

// This is a valid oop.

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 {

// Not cached in the java.lang.Thread oop yet (could be an

// older version of library).

if (thr != NULL) {

// The JavaThread is alive.

p = thr->parker();

if (p != NULL) {

// Cache the Parker in the java.lang.Thread oop for next time.

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

}

}

}

}

} // ThreadsListHandle is destroyed here.

if (p != NULL) {

HOTSPOT_THREAD_UNPARK((uintptr_t)p);

p->unpark();

}

}

}

}

Get thread object from jni environment

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

Get Parker object from park_event or JavaThread

Parker *p = (Parker *)addr_from_java(lp);

Parker *p = thr->parker();

Call unpark() on Parker object

p->unpark();

Thread

// JSR166 per-thread parker

private:

Parker* _parker;

public:

Parker* parker() { return _parker; }

void JavaThread::initialize() {

...

_parker = Parker::Allocate(this);

}

per-thread Parker object

_parker is initialized by JavaThread::initialize()

Parker

class Parker : public os::PlatformParker {

private:

volatile int _counter ;

Parker * FreeNext ;

JavaThread * AssociatedWith ; // Current association

public:

Parker() : PlatformParker() {

_counter = 0 ;

FreeNext = NULL ;

AssociatedWith = NULL ;

}

protected:

~Parker() { ShouldNotReachHere(); }

public:

// For simplicity of interface with Java, all forms of park (indefinite,

// relative, and absolute) are multiplexed into one call.

void park(bool isAbsolute, jlong time);

void unpark();

// Lifecycle operators

static Parker * Allocate (JavaThread * t) ;

static void Release (Parker * e) ;

private:

static Parker * volatile FreeList ;

static volatile int ListLock ;

};

Parker extends os::PlatformParker

Default value of volatile _counter is 0

PlatformParker

// JSR166 support

os::PlatformParker::PlatformParker() {

int status;

status = pthread_cond_init(&_cond[REL_INDEX], _condAttr);

assert_status(status == 0, status, "cond_init rel");

status = pthread_cond_init(&_cond[ABS_INDEX], NULL);

assert_status(status == 0, status, "cond_init abs");

status = pthread_mutex_init(_mutex, _mutexAttr);

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

_cur_index = -1; // mark as unused

}

Initialize condition variable _cond[0], used when isAbsolute is false

pthread_cond_init(&_cond[REL_INDEX], _condAttr);

Initialize condition variable _cond[1], used when isAbsolute is true

pthread_cond_init(&_cond[ABS_INDEX], NULL);

Initialize a mutex _mutex

pthread_mutex_init(_mutex, _mutexAttr);

park

// Parker::park decrements count if > 0, else does a condvar wait. Unpark

// sets count to 1 and signals condvar. Only one thread ever waits

// on the condvar. Contention seen when trying to park implies that someone

// is unparking you, so don't wait. And spurious returns are fine, so there

// is no need to track notifications.

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

// 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.

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) {

to_abstime(&absTime, time, isAbsolute);

}

// 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

// unparking. Also re-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(status == 0, status, "invariant");

// Paranoia to ensure our locked and lock-free paths interact

// correctly with each other and Java-level accesses.

OrderAccess::fence();

return;

}

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

jt->set_suspend_equivalent();

// cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()

assert(_cur_index == -1, "invariant");

if (time == 0) {

_cur_index = REL_INDEX; // arbitrary choice when not timed

status = pthread_cond_wait(&_cond[_cur_index], _mutex);

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

}

else {

_cur_index = isAbsolute ? ABS_INDEX : REL_INDEX;

status = pthread_cond_timedwait(&_cond[_cur_index], _mutex, &absTime);

assert_status(status == 0 || status == ETIMEDOUT,

status, "cond_timedwait");

}

_cur_index = -1;

_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();

}

}

if (Atomic::xchg(0, &_counter) > 0) return;

Performs atomic exchange of _counter to value 0, return previous value of _counter.

If previous value of _counter > 0, stop park.

This happens in case we call unpark before park.

LockSupport.unpark(Thread.currentThread()); LockSupport.park();

If previous value of _counter = 0, continue park.

if (Thread::is_interrupted(thread, false)) return;

Check if current thread is interrupted.

If current thread is interrupted, stop park.

This happens in case we interrupt current thread before park.

Thread.currentThread().interrupt(); LockSupport.park();

Else continue park.

Demultiplex/decode time arguments

time < 0, stop park.

time = 0 and isAbsolute = true, stop park.

time = 0 and isAbsolute = false, park forever until unpark.

time > 0, extract absTime.

to_abstime(&absTime, time, isAbsolute);

absTime.tv_sec and absTime.tv_usec represent seconds and microseconds since the Epoch1970-01-01 00:00:00 +0000 (UTC).

ThreadBlockInVM tbivm(jt);

Transit java thread status from running (_thread_in_vm) to blocked(_thread_blocked).

if (Thread::is_interrupted(thread, false) || pthread_mutex_trylock(_mutex) != 0) return;

Re-check if current thread is interrupted, and try to acquire lock on _mutex.

If current thread is interrupted, stop park.

This happens while t2 interrupted t1, and then t1 executed to 5.

Thread t1 = new Thread(() -> LockSupport.park());

Thread t2 = new Thread(() -> t1.interrupt());

t1.start();

t2.start();

If current thread can't acquire lock on _mutex, stop park.

This happens while t2 acquired lock on _mutex and then t1 executed to 5.

Thread t1 = new Thread(() -> LockSupport.park());

Thread t2 = new Thread(() -> LockSupport.unpark(t1););

t1.start();

t2.start();

Else acquire lock on _mutex and continue park.

if (_counter > 0) {_counter = 0; pthread_mutex_unlock(_mutex); return;}

If _counter > 0, stop park.

This happens while t2 finished unpark t1, and t1 executed to 6.

Thread t1 = new Thread(() -> LockSupport.park());

Thread t2 = new Thread(() -> LockSupport.unpark(t1););

t1.start();

t2.start();

OSThreadWaitState osts(thread->osthread(), false);

Set os thread state to wait.

pthread_cond_wait and pthread_cond_timedwait

Block current thread

time = 0

pthread_cond_wait(&_cond[REL_INDEX], _mutex);

time > 0

pthread_cond_timedwait(&_cond[isAbsolute ? ABS_INDEX : REL_INDEX], _mutex, &absTime);

_counter = 0; pthread_mutex_unlock(_mutex);

After thread is unblocked by unpark, set _counter = 0 and release _mutex lock.

unpark

void Parker::unpark() {

int status = pthread_mutex_lock(_mutex);

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

const int s = _counter;

_counter = 1;

// must capture correct index before unlocking

int index = _cur_index;

status = pthread_mutex_unlock(_mutex);

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

// Note that we signal() *after* dropping the lock for "immortal" Events.

// This is safe and avoids a common class of futile wakeups. In rare

// circumstances this can cause a thread to return prematurely from

// cond_{timed}wait() but the spurious wakeup is benign and the victim

// will simply re-test the condition and re-park itself.

// This provides particular benefit if the underlying platform does not

// provide wait morphing.

if (s < 1 && index != -1) {

// thread is definitely parked

status = pthread_cond_signal(&_cond[index]);

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

}

}

pthread_mutex_lock(_mutex);

Acquire mutex lock on _mutex.

const int s = _counter; _counter = 1; int index = _cur_index;

s = previous value of _counter.

_counter = 1.

_cur_index to get condition variable for unblocking.

pthread_mutex_unlock(_mutex);

Release mutex lock on _mutex.

if (s < 1 && index != -1) {pthread_cond_signal(&_cond[index]);}

If previous value of _counter < 1 and _cur_index != -1, unblock thread.

Summary

park set _counter to 0, block thread through pthread_cond_wait/pthread_cond_timedwait.

unpark set _counter to 1, unblock thread through pthread_cond_signal.

A call to park will return immediately if the permit is available(_counter = 1), consuming it in the process(_counter = 0); otherwise(_counter = 0) it may block. A call to unpark makes the permit available(_counter = 1), if it was not already available.

Reference