AQS是java.conccurent包下诸多工具类的抽象基类，借以AQS抽象基类，实现如lock,unlock,condition.wait,condition.signal等重要功能。
其中ReentrantLock(可重入锁)就是借以AQS实现加锁，释放锁，线程阻塞，线程唤醒等功能。
对于独占式(Exclusive)
lock()->acquire()--->tryAcquire()[模板方法]
|---->acquireQueued(addWaiter())
unlock()->release()--->tryRelease()[模板方法]
对于共享式(Shard)
lock()->acquireShard()->tryAcquireShard()[模板方法]
unlock()->releaseShard()->tryReleaseShard()[模板方法]
在独占式模式下，在线程A获取锁后，线程B也来抢占锁，但是此时线程A占有着锁，线程B就会加入AQS的双向链表中，在条件满足的情况下（前驱节点有waitStatus < 0存在）就会进行阻塞。
LockSupport.park()
AbstractQueuedSynchronizer中的shouldParkAfterFailedAcquire(..)方法判断是否满足阻塞条件
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
/*
* This node has already set status asking a release
* to signal it, so it can safely park.
*/
return true;
if (ws > 0) {
/*
* Predecessor was cancelled. Skip over predecessors and
* indicate retry.
*/
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
/*
* waitStatus must be 0 or PROPAGATE. Indicate that we
* need a signal, but don't park yet. Caller will need to
* retry to make sure it cannot acquire before parking.
*/
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
线程调用LockSupport.park()阻塞线程
public static void park(Object blocker) {
Thread t = Thread.currentThread();
setBlocker(t, blocker); // 记录线程对象
UNSAFE.park(false, 0L);
setBlocker(t, null); // 记录线程对象
}
调用UNSAFE.park(false, 0L);查看此方法已经变成了本地方法
public native void park(boolean var1, long var2);
找到/hotspot/src/share/vm/prims/unsafe.cpp
UNSAFE_ENTRY(void, Unsafe_Park(JNIEnv *env, jobject unsafe, jboolean isAbsolute, jlong time))
UnsafeWrapper("Unsafe_Park");
EventThreadPark event;
#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()方法
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 */
if (event.should_commit()) {
oop obj = thread->current_park_blocker();
event.set_klass((obj != NULL) ? obj->klass() : NULL);
event.set_timeout(time);
event.set_address((obj != NULL) ? (TYPE_ADDRESS) cast_from_oop(obj) : 0);
event.commit();
}
UNSAFE_END
找到\hotspot\src\share\vm\runtime\thread.cpp，\hotspot\src\share\vm\runtime\thread.hpp
通过thread对象下的parker函数返回parker对象
// JSR166 per-thread parker
private:
Parker* _parker;
public:
Parker* parker() { return _parker; }
\hotspot\src\share\vm\runtime\park.hpp，对应的Parker类
class Parker : public os::PlatformParker {
private:
volatile int _counter ; //计数
Parker * FreeNext ; //指向下一个Parker
JavaThread * AssociatedWith ; // 指向parker所属的线程。
public:
Parker() : PlatformParker() {
_counter = 0 ; //初始化为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类的park函数，Parker继承了PlatformParker。
class PlatformParker : public CHeapObj {
protected:
enum {
REL_INDEX = 0,
ABS_INDEX = 1
};
int _cur_index; // 条件变量数组下标，which cond is in use: -1, 0, 1
pthread_mutex_t _mutex [1] ; //pthread互斥锁
pthread_cond_t _cond [2] ; // pthread条件变量数组,一个用于相对时间，一个用于绝对时间。
public: // TODO-FIXME: make dtor private
~PlatformParker() { guarantee (0, "invariant") ; }
public:
PlatformParker() {
int status;
status = pthread_cond_init (&_cond[REL_INDEX], os::Linux::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, NULL);
assert_status(status == 0, status, "mutex_init");
_cur_index = -1; // mark as unused
}
};
PlatformParker主要看三个成员变量，_cur_index, _mutex, _cond。其中mutex和cond就是很熟悉的glibc nptl包中符合posix标准的线程同步工具，一个互斥锁一个条件变量。再看thread和Parker的关系，在hotspot的Thread类的NameThread内部类中有一个 Parker成员变量。说明parker是线程变量，在创建线程的时候就会生成一个parker实例。
以\hotspot\src\os\linux\vm\os_linux.cpp为例，再看park()实现
void Parker::park(bool isAbsolute, jlong time) {
//原子交换，如果_counter > 0,则将_counter置为0，直接返回，否则_counter为0
if (Atomic::xchg(0, &_counter) > 0) return;
//获取当前线程
Thread* thread = Thread::current();
assert(thread->is_Java_thread(), "Must be JavaThread");
//下转型为java线程
JavaThread *jt = (JavaThread *)thread;
//如果当前线程设置了中断标志，调用park则直接返回，所以如果在park之前调用了
//interrupt就会直接返回
if (Thread::is_interrupted(thread, false)) {
return;
}
// 高精度绝对时间变量
timespec absTime;
//如果time小于0，或者isAbsolute是true并且time等于0则直接返回
if (time < 0 || (isAbsolute && time == 0) ) { // don't wait at all
return;
}
//如果time大于0，则根据是否是高精度定时计算定时时间
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);
//如果当前线程设置了中断标志，或者获取mutex互斥锁失败则直接返回
//由于Parker是每个线程都有的，所以_counter cond mutex都是每个线程都有的，
//不是所有线程共享的所以加锁失败只有两种情况，第一unpark已经加锁这时只需要返回即可，
//第二调用pthread_mutex_trylock出错。对于第一种情况就类似是unpark先调用的情况，所以
//直接返回。
if (Thread::is_interrupted(thread, false) || pthread_mutex_trylock(_mutex) != 0) {
return;
}
int status ;
//如果_counter大于0，说明unpark已经调用完成了将_counter置为了1，
//现在只需将_counter置0，解锁，返回
if (_counter > 0) { // no wait needed
_counter = 0;
status = pthread_mutex_unlock(_mutex);
assert (status == 0, "invariant");
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");
//如果time等于0，说明是相对时间也就是isAbsolute是fasle(否则前面就直接返回了),则直接挂起
if (time == 0) {
_cur_index = REL_INDEX; // arbitrary choice when not timed
status = pthread_cond_wait (&_cond[_cur_index], _mutex) ;
} else { //如果time非0
//判断isAbsolute是false还是true，false的话使用_cond[0]，否则用_cond[1]
_cur_index = isAbsolute ? ABS_INDEX : REL_INDEX;
//使用条件变量使得当前线程挂起。
status = os::Linux::safe_cond_timedwait (&_cond[_cur_index], _mutex, &absTime) ;
//如果挂起失败则销毁当前的条件变量重新初始化。
if (status != 0 && WorkAroundNPTLTimedWaitHang) {
pthread_cond_destroy (&_cond[_cur_index]) ;
pthread_cond_init (&_cond[_cur_index], isAbsolute ? NULL : os::Linux::condAttr());
}
}
//如果pthread_cond_wait成功则以下代码都是线程被唤醒后执行的。
_cur_index = -1;
assert_status(status == 0 || status == EINTR ||
status == ETIME || status == ETIMEDOUT,
status, "cond_timedwait");
#ifdef ASSERT
pthread_sigmask(SIG_SETMASK, &oldsigs, NULL);
#endif
//将_counter变量重新置为1
_counter = 0 ;
//解锁
status = pthread_mutex_unlock(_mutex) ;
assert_status(status == 0, status, "invariant") ;
// 使用内存屏障使_counter对其它线程可见
OrderAccess::fence();
// 如果在park线程挂起的时候调用了stop或者suspend则还需要将线程挂起不能返回
if (jt->handle_special_suspend_equivalent_condition()) {
jt->java_suspend_self();
}
}
其中：
/**加锁**/
pthread\nptl\pthread_mutex_trylock.c
(..)，该函数表示，用来锁住mutex 所指定的互斥体，但不阻塞。如果该互斥体已经被上锁，该调用不会阻塞等待，而会返回一个错误代码。
/**休眠**/
pthread_cond_wait(..)
/**解锁**/
pthread_mutex_unlock(..)