static final class FairSync extends Sync {final void lock() {acquire(1);}/*** Fair version of tryAcquire.  Don't grant access unless* recursive call or no waiters or is first.*/protected final boolean tryAcquire(int acquires) {final Thread current = Thread.currentThread();int c = getState();if (c == 0) {if (!hasQueuedPredecessors() &&compareAndSetState(0, acquires)) {setExclusiveOwnerThread(current);return true;}}else if (current == getExclusiveOwnerThread()) {int nextc = c + acquires;if (nextc < 0)throw new Error("Maximum lock count exceeded");setState(nextc);return true;}return false;}}AbstractQueuedSynchronizer.javapublic final void acquire(int arg) {if (!tryAcquire(arg) &&acquireQueued(addWaiter(Node.EXCLUSIVE), arg))selfInterrupt();}

LockSupport.javapublic static void park(Object blocker) {Thread t = Thread.currentThread();setBlocker(t, blocker);UNSAFE.park(false, 0L);setBlocker(t, null);}

void Parker::park(bool isAbsolute, jlong time) {...//获得当前线程Thread* thread = Thread::current();assert(thread->is_Java_thread(), "Must be JavaThread");JavaThread *jt = (JavaThread *)thread;//如果当前线程被设置了interrupted标记，则直接返回if (Thread::is_interrupted(thread, false)) {return;}if (time > 0) {//unpacktime中根据isAbsolute的值来填充absTime结构体，isAbsolute为true时，time代表绝对时间且单位是毫秒，否则time是相对时间且单位是纳秒//absTime.tvsec代表了对于时间的秒//absTime.tv_nsec代表对应时间的纳秒unpackTime(&absTime, isAbsolute, time);}//调用mutex trylock方法if (Thread::is_interrupted(thread, false) || pthread_mutex_trylock(_mutex) != 0) {return;}//_counter是一个许可的数量，跟ReentrantLock里定义的许可变量基本都是一个原理。 unpack方法调用时会将_counter赋值为1。//_counter>0代表已经有人调用了unpark，所以不用阻塞int status ;if (_counter > 0)  { // no wait needed_counter = 0;//释放mutex锁status = pthread_mutex_unlock(_mutex);return;}//设置线程状态为CONDVAR_WAITOSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);...//等待_cur_index = isAbsolute ? ABS_INDEX : REL_INDEX;pthread_cond_timedwait(&_cond[_cur_index], _mutex,  &absTime);...//释放mutex锁status = pthread_mutex_unlock(_mutex) ;}

  enum ThreadState {ALLOCATED,                    // Memory has been allocated but not initializedINITIALIZED,                  // The thread has been initialized but yet startedRUNNABLE,                     // Has been started and is runnable, but not necessarily runningMONITOR_WAIT,                 // Waiting on a contended monitor lockCONDVAR_WAIT,                 // Waiting on a condition variableOBJECT_WAIT,                  // Waiting on an Object.wait() callBREAKPOINTED,                 // Suspended at breakpointSLEEPING,                     // Thread.sleep()ZOMBIE                        // All done, but not reclaimed yet
};

//pthread_mutex_t是posix中的互斥锁结构体
int
__pthread_mutex_trylock (mutex)pthread_mutex_t *mutex;
{int oldval;pid_t id = THREAD_GETMEM (THREAD_SELF, tid);
switch (__builtin_expect (PTHREAD_MUTEX_TYPE (mutex),PTHREAD_MUTEX_TIMED_NP)){case PTHREAD_MUTEX_ERRORCHECK_NP:case PTHREAD_MUTEX_TIMED_NP:case PTHREAD_MUTEX_ADAPTIVE_NP:/* Normal mutex.  */if (lll_trylock (mutex->__data.__lock) != 0)break;/* Record the ownership.  */mutex->__data.__owner = id;++mutex->__data.__nusers;return 0;}} //以下代码在lowlevellock.h中
   #define __lll_trylock(futex) \(atomic_compare_and_exchange_val_acq (futex, 1, 0) != 0)#define lll_trylock(futex) __lll_trylock (&(futex))

pthread_mutex_unlock.cint
internal_function attribute_hidden
__pthread_mutex_unlock_usercnt (mutex, decr)pthread_mutex_t *mutex;int decr;
{if (__builtin_expect (type, PTHREAD_MUTEX_TIMED_NP)== PTHREAD_MUTEX_TIMED_NP){/* Always reset the owner field.  */normal:mutex->__data.__owner = 0;if (decr)/* One less user.  */--mutex->__data.__nusers;/* Unlock.  */lll_unlock (mutex->__data.__lock, PTHREAD_MUTEX_PSHARED (mutex));return 0;}}
pthread_mutex_unlock将mutex中的owner清空，并调用了lll_unlock方法lowlevellock.h#define __lll_unlock(futex, private)                          \((void) ({                                      \int *__futex = (futex);                              \int __val = atomic_exchange_rel (__futex, 0);                  \\if (__builtin_expect (__val > 1, 0))                      \lll_futex_wake (__futex, 1, private);                      \}))
#define lll_unlock(futex, private) __lll_unlock(&(futex), private)#define lll_futex_wake(ftx, nr, private)                \
({                                    \DO_INLINE_SYSCALL(futex, 3, (long) (ftx),                \__lll_private_flag (FUTEX_WAKE, private),        \(int) (nr));                    \_r10 == -1 ? -_retval : _retval;                    \
})

#define __lll_lock(futex, private)                          \((void) ({                                      \int *__futex = (futex);                              \if (__builtin_expect (atomic_compare_and_exchange_bool_acq (__futex,      \1, 0), 0))    \{                                          \if (__builtin_constant_p (private) && (private) == LLL_PRIVATE)          \__lll_lock_wait_private (__futex);                      \else                                      \__lll_lock_wait (__futex, private);                      \}                                          \}))
#define lll_lock(futex, private) __lll_lock (&(futex), private)void
__lll_lock_wait_private (int *futex)
{
//第一次进来的时候futex==1,所以不会走这个ifif (*futex == 2)lll_futex_wait (futex, 2, LLL_PRIVATE);
//在这里会把futex设置成2，并调用futex_wait让当前线程等待while (atomic_exchange_acq (futex, 2) != 0)lll_futex_wait (futex, 2, LLL_PRIVATE);
}

int
int
__pthread_cond_timedwait (cond, mutex, abstime)pthread_cond_t *cond;pthread_mutex_t *mutex;const struct timespec *abstime;
{struct _pthread_cleanup_buffer buffer;struct _condvar_cleanup_buffer cbuffer;int result = 0;/* Catch invalid parameters.  */if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000)return EINVAL;int pshared = (cond->__data.__mutex == (void *) ~0l)? LLL_SHARED : LLL_PRIVATE;//1.获得cond锁lll_lock (cond->__data.__lock, pshared);//2.释放mutex锁int err = __pthread_mutex_unlock_usercnt (mutex, 0);if (err){lll_unlock (cond->__data.__lock, pshared);return err;}/* We have one new user of the condvar.  *///每执行一次wait(pthread_cond_timedwait/pthread_cond_wait)，__total_seq就会+1++cond->__data.__total_seq;//用来执行futex_wait的变量++cond->__data.__futex;//标识该cond还有多少线程在使用，pthread_cond_destroy需要等待所有的操作完成cond->__data.__nwaiters += 1 << COND_NWAITERS_SHIFT;/* Remember the mutex we are using here.  If there is already adifferent address store this is a bad user bug.  Do not storeanything for pshared condvars.  *///保存mutex锁if (cond->__data.__mutex != (void *) ~0l)cond->__data.__mutex = mutex;/* Prepare structure passed to cancellation handler.  */cbuffer.cond = cond;cbuffer.mutex = mutex;/* Before we block we enable cancellation.  Therefore we have toinstall a cancellation handler.  */__pthread_cleanup_push (&buffer, __condvar_cleanup, &cbuffer);/* The current values of the wakeup counter.  The "woken" countermust exceed this value.  *///记录futex_wait前的__wakeup_seq（为该cond上执行了多少次sign操作+timeout次数）和__broadcast_seq（代表在该cond上执行了多少次broadcast）unsigned long long int val;unsigned long long int seq;val = seq = cond->__data.__wakeup_seq;/* Remember the broadcast counter.  */cbuffer.bc_seq = cond->__data.__broadcast_seq;while (1){//3.计算要wait的相对时间
      struct timespec rt;{
#ifdef __NR_clock_gettimeINTERNAL_SYSCALL_DECL (err);int ret;ret = INTERNAL_VSYSCALL (clock_gettime, err, 2,(cond->__data.__nwaiters& ((1 << COND_NWAITERS_SHIFT) - 1)),&rt);
# ifndef __ASSUME_POSIX_TIMERSif (__builtin_expect (INTERNAL_SYSCALL_ERROR_P (ret, err), 0)){struct timeval tv;(void) gettimeofday (&tv, NULL);/* Convert the absolute timeout value to a relative timeout.  */rt.tv_sec = abstime->tv_sec - tv.tv_sec;rt.tv_nsec = abstime->tv_nsec - tv.tv_usec * 1000;}else
# endif{/* Convert the absolute timeout value to a relative timeout.  */rt.tv_sec = abstime->tv_sec - rt.tv_sec;rt.tv_nsec = abstime->tv_nsec - rt.tv_nsec;}
#else/* Get the current time.  So far we support only one clock.  */struct timeval tv;(void) gettimeofday (&tv, NULL);/* Convert the absolute timeout value to a relative timeout.  */rt.tv_sec = abstime->tv_sec - tv.tv_sec;rt.tv_nsec = abstime->tv_nsec - tv.tv_usec * 1000;
#endif}if (rt.tv_nsec < 0){rt.tv_nsec += 1000000000;--rt.tv_sec;}/*---计算要wait的相对时间 end---- *///是否超时/* Did we already time out?  */if (__builtin_expect (rt.tv_sec < 0, 0)){//被broadcast唤醒，这里疑问的是，为什么不需要判断__wakeup_seq？if (cbuffer.bc_seq != cond->__data.__broadcast_seq)goto bc_out;goto timeout;}unsigned int futex_val = cond->__data.__futex;//4.释放cond锁，准备waitlll_unlock (cond->__data.__lock, pshared);/* Enable asynchronous cancellation.  Required by the standard.  */cbuffer.oldtype = __pthread_enable_asynccancel ();//5.调用futex_wait/* Wait until woken by signal or broadcast.  */err = lll_futex_timed_wait (&cond->__data.__futex,futex_val, &rt, pshared);/* Disable asynchronous cancellation.  */__pthread_disable_asynccancel (cbuffer.oldtype);//6.重新获得cond锁，因为又要访问&修改cond的数据了lll_lock (cond->__data.__lock, pshared);//__broadcast_seq值发生改变，代表发生了有线程调用了广播if (cbuffer.bc_seq != cond->__data.__broadcast_seq)goto bc_out;//判断是否是被sign唤醒的，sign会增加__wakeup_seq//第二个条件cond->__data.__woken_seq != val的意义在于//可能两个线程A、B在wait，一个线程调用了sign导致A被唤醒，这时B因为超时被唤醒//对于B线程来说，执行到这里时第一个条件也是满足的，从而导致上层拿到的result不是超时//所以这里需要判断下__woken_seq（即该cond已经被唤醒的线程数）是否等于__wakeup_seq（sign执行次数+timeout次数）val = cond->__data.__wakeup_seq;if (val != seq && cond->__data.__woken_seq != val)break;/* Not woken yet.  Maybe the time expired?  */if (__builtin_expect (err == -ETIMEDOUT, 0)){timeout:/* Yep.  Adjust the counters.  */++cond->__data.__wakeup_seq;++cond->__data.__futex;/* The error value.  */result = ETIMEDOUT;break;}}//一个线程已经醒了所以这里__woken_seq +1++cond->__data.__woken_seq;bc_out://
  cond->__data.__nwaiters -= 1 << COND_NWAITERS_SHIFT;/* If pthread_cond_destroy was called on this variable already,notify the pthread_cond_destroy caller all waiters have leftand it can be successfully destroyed.  */if (cond->__data.__total_seq == -1ULL&& cond->__data.__nwaiters < (1 << COND_NWAITERS_SHIFT))lll_futex_wake (&cond->__data.__nwaiters, 1, pshared);//9.cond数据修改完毕，释放锁lll_unlock (cond->__data.__lock, pshared);/* The cancellation handling is back to normal, remove the handler.  */__pthread_cleanup_pop (&buffer, 0);//10.重新获得mutex锁err = __pthread_mutex_cond_lock (mutex);return err ?: result;
}

Object condObj=new Object();
voilate int flag = 0;
public void waitTest(){if(flag == 0){condObj.wait();}
}
public void notifyTest(){flag=1;condObj.notify();
}

Object condObj=new Object();
voilate int flag = 0;
public void waitTest(){synchronized(condObj){if(flag == 0){condObj.wait();}}}
public void notifyTest(){synchronized(condObj){flag=1;condObj.notify();}
}

int
__pthread_cond_signal (cond)pthread_cond_t *cond;
{int pshared = (cond->__data.__mutex == (void *) ~0l)? LLL_SHARED : LLL_PRIVATE;//因为要操作cond的数据，所以要加锁lll_lock (cond->__data.__lock, pshared);/* Are there any waiters to be woken?  */if (cond->__data.__total_seq > cond->__data.__wakeup_seq){//__wakeup_seq为执行sign与timeout次数的和++cond->__data.__wakeup_seq;++cond->__data.__futex;...//唤醒wait的线程lll_futex_wake (&cond->__data.__futex, 1, pshared);}/* We are done.  */lll_unlock (cond->__data.__lock, pshared);return 0;
}