☕️【Java 技术之旅】从底层分析 LockSupport 原理机制

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

class Parker : public os::PlatformParker {  private:    volatile int _counter ;    ...  public:    void park(bool isAbsolute, jlong time);    void unpark();    ...  }  class PlatformParker : public CHeapObj<mtInternal> {    protected:      pthread_mutex_t _mutex [1] ;      pthread_cond_t  _cond  [1] ;      ...  }  

void Parker::park(bool isAbsolute, jlong time) {    // Ideally we'd do something useful while spinning, such    // as calling unpackTime().        // 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;  

ThreadBlockInVM tbivm(jt);  if (_counter > 0)  { // no wait needed    _counter = 0;    status = pthread_mutex_unlock(_mutex);  

if (time == 0) {    status = pthread_cond_wait (_cond, _mutex) ;  }  _counter = 0 ;  status = pthread_mutex_unlock(_mutex) ;  assert_status(status == 0, status, "invariant") ;  OrderAccess::fence();  

void Parker::unpark() {    int s, status ;    status = pthread_mutex_lock(_mutex);    assert (status == 0, "invariant") ;    s = _counter;    _counter = 1;    if (s < 1) {       if (WorkAroundNPTLTimedWaitHang) {          status = pthread_cond_signal (_cond) ;          assert (status == 0, "invariant") ;          status = pthread_mutex_unlock(_mutex);          assert (status == 0, "invariant") ;       } else {          status = pthread_mutex_unlock(_mutex);          assert (status == 0, "invariant") ;          status = pthread_cond_signal (_cond) ;          assert (status == 0, "invariant") ;       }    } else {      pthread_mutex_unlock(_mutex);      assert (status == 0, "invariant") ;    }  }

if (time == 0) {    status = pthread_cond_wait (_cond, _mutex) ;  }  

Some other thread invokes unpark with the current thread as the target; orSome other thread interrupts the current thread; orThe call spuriously (that is, for no reason) returns.

// We use placement-new to force ParkEvent instances to be  // aligned on 256-byte address boundaries.  This ensures that the least  // significant byte of a ParkEvent address is always 0.     void * operator new (size_t sz) ;  Parker里使用了一个无锁的队列在分配释放Parker实例：

volatile int Parker::ListLock = 0 ;  Parker * volatile Parker::FreeList = NULL ;    Parker * Parker::Allocate (JavaThread * t) {    guarantee (t != NULL, "invariant") ;    Parker * p ;      // Start by trying to recycle an existing but unassociated    // Parker from the global free list.    for (;;) {      p = FreeList ;      if (p  == NULL) break ;      // 1: Detach      // Tantamount to p = Swap (&FreeList, NULL)      if (Atomic::cmpxchg_ptr (NULL, &FreeList, p) != p) {         continue ;      }        // We've detached the list.  The list in-hand is now      // local to this thread.   This thread can operate on the      // list without risk of interference from other threads.      // 2: Extract -- pop the 1st element from the list.      Parker * List = p->FreeNext ;      if (List == NULL) break ;      for (;;) {          // 3: Try to reattach the residual list          guarantee (List != NULL, "invariant") ;          Parker * Arv =  (Parker *) Atomic::cmpxchg_ptr (List, &FreeList, NULL) ;          if (Arv == NULL) break ;            // New nodes arrived.  Try to detach the recent arrivals.          if (Atomic::cmpxchg_ptr (NULL, &FreeList, Arv) != Arv) {              continue ;          }          guarantee (Arv != NULL, "invariant") ;          // 4: Merge Arv into List          Parker * Tail = List ;          while (Tail->FreeNext != NULL) Tail = Tail->FreeNext ;          Tail->FreeNext = Arv ;      }      break ;    }      if (p != NULL) {      guarantee (p->AssociatedWith == NULL, "invariant") ;    } else {      // Do this the hard way -- materialize a new Parker..      // In rare cases an allocating thread might detach      // a long list -- installing null into FreeList --and      // then stall.  Another thread calling Allocate() would see      // FreeList == null and then invoke the ctor.  In this case we      // end up with more Parkers in circulation than we need, but      // the race is rare and the outcome is benign.      // Ideally, the # of extant Parkers is equal to the      // maximum # of threads that existed at any one time.      // Because of the race mentioned above, segments of the      // freelist can be transiently inaccessible.  At worst      // we may end up with the # of Parkers in circulation      // slightly above the ideal.      p = new Parker() ;    }    p->AssociatedWith = t ;          // Associate p with t    p->FreeNext       = NULL ;    return p ;  }      void Parker::Release (Parker * p) {    if (p == NULL) return ;    guarantee (p->AssociatedWith != NULL, "invariant") ;    guarantee (p->FreeNext == NULL      , "invariant") ;    p->AssociatedWith = NULL ;    for (;;) {      // Push p onto FreeList      Parker * List = FreeList ;      p->FreeNext = List ;      if (Atomic::cmpxchg_ptr (p, &FreeList, List) == List) break ;    }  }