面试多线程同步，你必须要思考的问题

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;  }  } 

public final void acquire(int arg) {  if (!tryAcquire(arg) &&  acquireQueued(addWaiter(Node.EXCLUSIVE), arg))  selfInterrupt();  } 

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

Unsafe_Park(JNIEnv *env, jobject unsafe, jboolean isAbsolute, jlong time){ ... thread->parker()->park(isAbsolute != 0, time); ... } 

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_WAIT  OSThreadWaitState 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 initialized  INITIALIZED, // The thread has been initialized but yet started  RUNNABLE, // Has been started and is runnable, but not necessarily running  MONITOR_WAIT, // Waiting on a contended monitor lock  CONDVAR_WAIT, // Waiting on a condition variable  OBJECT_WAIT, // Waiting on an Object.wait() call  BREAKPOINTED, // Suspended at breakpoint  SLEEPING, // 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)) 

int 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;  }  } 

 #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,所以不会走这个if  if (*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 a  different address store this is a bad user bug. Do not store  anything 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 to  install a cancellation handler. */  __pthread_cleanup_push (&buffer, __condvar_cleanup, &cbuffer);  /* The current values of the wakeup counter. The "woken" counter  must 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_gettime  INTERNAL_SYSCALL_DECL (err);  int ret;  ret = INTERNAL_VSYSCALL (clock_gettime, err, 2,  (cond->__data.__nwaiters  & ((1 << COND_NWAITERS_SHIFT) - 1)),  &rt); # ifndef __ASSUME_POSIX_TIMERS  if (__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锁，准备wait  lll_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 left  and 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; }