重量级锁源码分析

锁膨胀

synchronizer#inflate^[1]代码分析的注释版本：

ObjectMonitor* ObjectSynchronizer::inflate(Thread * Self, oop object, const InflateCause cause) {
 EventJavaMonitorInflate event;
 
 for (;;) {
  const markOop mark = object->mark();
  // 当markOop是以下状态时：
  // Inflated - 重量级锁，直接返回
  // Stack-locked  - 轻量级锁，锁膨胀
  // INFLATING - 膨胀中，忙等待直到膨胀完成
  // Neutral - 无锁状态，锁膨胀，见Tips 1
  // BIASED - 偏向锁，非法状态，不应该在这里出现，见Tips 2
  
  // 重量级锁状态
  if (mark->has_monitor()) {
   ObjectMonitor * inf = mark->monitor();
   return inf;
  }  

  // 膨胀中的状态，当前线程必须等待膨胀中状态完成后重新检查状态
  if (mark == markOopDesc::INFLATING()) {
   // 读取稳定的markOop状态（Inflated）
   // 内部通过自旋不断读取，每次读取后会有“暂停”
   // 多核采用自旋（SpinPause）
   // 单核采用naked_yield/_ParkEvent->park
   ReadStableMark(object);
   continue;
  }

  // 轻量级锁状态，锁膨胀
  if (mark->has_locker()) {
   // 创建并初始化ObjectMonitor
   ObjectMonitor * m = omAlloc(Self);
   m->Recycle();
   m->_Responsible  = NULL;
   m->_recursions   = 0;
   m->_SpinDuration = ObjectMonitor::Knob_SpinLimit;

   // CAS替换（设置对象的markOop为INFLATING状态）
   markOop cmp = object->cas_set_mark(markOopDesc::INFLATING(), mark);
   if (cmp != mark) {
    omRelease(Self, m, true);
    continue;
   }
   
   // ObjectMonitor字段赋值
   markOop dmw = mark->displaced_mark_helper();
   m->set_header(dmw);
   // 轻量级锁的锁膨胀，锁的持有者为轻量级锁的持有者
   m->set_owner(mark->locker());
   m->set_object(object);

   // 设置markOop的状态为重量级锁
   object->release_set_mark(markOopDesc::encode(m));
   if (event.should_commit()) {
    // 发送锁膨胀事件
    post_monitor_inflate_event(&event, object, cause);
   }
   return m;
  }
  // 无锁状态，锁膨胀
  // 创建并初始化ObjectMonitor
  ObjectMonitor * m = omAlloc(Self);
  m->Recycle();
  m->set_header(mark);
  // 无锁状态的锁膨胀，并没有锁的持有者
  m->set_owner(NULL);
  m->set_object(object);
  m->_recursions   = 0;
  m->_Responsible  = NULL;
  m->_SpinDuration = ObjectMonitor::Knob_SpinLimit;
  
  // // CAS替换（设置对象的markOop为Inflated状态）
  if (object->cas_set_mark(markOopDesc::encode(m), mark) != mark) {
   m->set_object(NULL);
   m->set_owner(NULL);
   m->Recycle();
   // 替换失败，释放锁
   omRelease(Self, m, true);
   m = NULL;
   continue;
  }

  if (event.should_commit()) {
   post_monitor_inflate_event(&event, object, cause);
  }
  return m;
 }  
}

Tips：

1. Stack-locked状态和Neutral状态的锁膨胀，从原文中看似乎有些差别；
2. 偏向锁一口吃不成个“胖子”，无法直接升级成重量级锁。

适应性自旋

int ObjectMonitor::TrySpin (Thread * Self) {
 // 固定次数自旋，注释中用了Dumb，brutal来形容这个自旋，hhh
 // Java 1.6前：Knob_FixedSpin = 10
 // Java 1.6后：Knob_FixedSpin = 0
 int ctr = Knob_FixedSpin;
 if (ctr != 0) {
  while (--ctr >= 0) {
   if (TryLock (Self) > 0)
    return 1;
   SpinPause ();
  }
  return 0;
 }
 // Knob_PreSpin = 10
 // Knob_SpinLimit = 5000
 // Knob_Poverty = 1000
 // Knob_BonusB = 100
 for (ctr = Knob_PreSpin + 1; --ctr >= 0; ) {
  if (TryLock(Self) > 0) {
   int x = _SpinDuration;
   if (x < Knob_SpinLimit) {
    if (x < Knob_Poverty)
     x = Knob_Poverty;
    // 注意ObjectSynchronizer::inflate中有对_SpinDuration进行处理
    _SpinDuration = x + Knob_BonusB;
   }
   return 1;
  }
  SpinPause ();
 }
 
 // Knob_SpinBase = 10
 ctr = _SpinDuration;
 if (ctr < Knob_SpinBase)
  ctr = Knob_SpinBase;
 if (ctr <= 0)
  return 0;
 // Knob_SuccRestrict = 0
 if (Knob_SuccRestrict && _succ != NULL)
  return 0;
 // Knob_OState = 3
 // NotRunnable判断线程是否退出
 if (Knob_OState && NotRunnable (Self, (Thread *) _owner)) {
  return 0;
 }
 //Knob_MaxSpinners = -1
 int MaxSpin = Knob_MaxSpinners;
 if (MaxSpin >= 0) {
  if (_Spinner > MaxSpin) {
   return 0;
  }
  // _Spinner + 1
  Adjust(&_Spinner, 1);
 }
 int hits    = 0;
 int msk     = 0;
 // Knob_CASPenalty = -1
 // Knob_OXPenalty = -1
 // Knob_SpinSetSucc = 1
 int caspty  = Knob_CASPenalty;
 int oxpty   = Knob_OXPenalty;
 int sss     = Knob_SpinSetSucc;
 if (sss && _succ == NULL )
  _succ = Self;
 hread * prv = NULL;
 while (--ctr >= 0) {
  // 0xFF（16进制） =256
  if ((ctr & 0xFF) == 0) {
   // 每自旋256次，检查安全点同步
   if (SafepointSynchronize::do_call_back()) {
    // 跳转到Abort
    goto Abort;
   }
   
   // Knob_UsePause = 1
   if (Knob_UsePause & 1)
    SpinPause ();
   }
   
   if (Knob_UsePause & 2)
    SpinPause();
   if (ctr & msk)
    continue;
   ++hits;
   // 0xF（16进制） = 15
   if ((hits & 0xF) == 0) {
    // BackOffMask = 0
    msk = ((msk << 2)  | 3) & BackOffMask;
   }
   
   Thread * ox = (Thread *) _owner;
   if (ox == NULL) {
    // CAS抢占锁
    ox = (Thread *) Atomic::cmpxchg_ptr (Self, &_owner, NULL);
    if (ox == NULL) {
     if (sss && _succ == Self) {
      _succ = NULL;
     }
    // _Spinner - 1
    if (MaxSpin > 0)
     Adjust (&_Spinner, -1);
    //增加_SpinDuration
    int x = _SpinDuration;
    if (x < Knob_SpinLimit) {
     if (x < Knob_Poverty)
      x = Knob_Poverty;
     _SpinDuration = x + Knob_Bonus;
    }
    return 1;
   }
   
   //CAS抢占失败
   // caspty = -1
   prv = ox;
   if (caspty == -2)
    break;
   if (caspty == -1)
    goto Abort;
   ctr -= caspty;
   continue;
  }
  
  //持有锁的线程发生改变
  // oxpty = -1
  if (ox != prv && prv != NULL ) {
   if (oxpty == -2)
    break;
   if (oxpty == -1)
    goto Abort;
   ctr -= oxpty;
  }
  //记录当前持有锁的线程
  prv = ox;
  //持有锁的线程退出
  if (Knob_OState && NotRunnable (Self, ox)) {
   goto Abort;
  }
  
  if (sss && _succ == NULL )
   _succ = Self;
  }
  
  {
   int x = _SpinDuration;
   if (x > 0) {
    //Knob_Penalty = 200
    x -= Knob_Penalty;
   if (x < 0)
    x = 0;
   _SpinDuration = x;
  }
 }
 Abort:
  if (MaxSpin >= 0)
   Adjust (&_Spinner, -1);
  if (sss && _succ == Self) {
   _succ = NULL;
  OrderAccess::fence();
  if (TryLock(Self) > 0)
   return 1;
  }
 return 0;
}

唤醒策略

void ObjectMonitor::exit(bool not_suspended, TRAPS) {
 Thread * const Self = THREAD;
 for (;;) {
  ObjectWaiter * w = NULL;
  int QMode = Knob_QMode;
  
  // 策略2
  if (QMode == 2 && _cxq != NULL) {
   w = _cxq;
   ExitEpilog(Self, w);
   return;
  }
  
  // 策略3
  if (QMode == 3 && _cxq != NULL) {
   w = _cxq;
   for (;;) {
    ObjectWaiter * u = Atomic::cmpxchg((ObjectWaiter*)NULL, &_cxq, w);
    if (u == w) 
     break;
    w = u;
   }
   ObjectWaiter * q = NULL;
   ObjectWaiter * p;
   for (p = w; p != NULL; p = p->_next) {
    p->TState = ObjectWaiter::TS_ENTER;
    p->_prev = q;
    q = p;
   }
   ObjectWaiter * Tail;
   for (Tail = _EntryList; Tail != NULL && Tail->_next != NULL; Tail = Tail->_next);
   if (Tail == NULL) {
    _EntryList = w;
   } else {
    Tail->_next = w;
    w->_prev = Tail;
   }
  }
  
  // 策略4
  if (QMode == 4 && _cxq != NULL) {
   w = _cxq;
   for (;;) {
    ObjectWaiter * u = Atomic::cmpxchg((ObjectWaiter*)NULL, &_cxq, w);
    if (u == w) 
     break;
    w = u;
   }
   ObjectWaiter * q = NULL;
   ObjectWaiter * p;
   for (p = w; p != NULL; p = p->_next) {
    p->TState = ObjectWaiter::TS_ENTER;
    p->_prev = q;
    q = p;
   }
   if (_EntryList != NULL) {
    q->_next = _EntryList;
    _EntryList->_prev = q;
   }
   _EntryList = w;
  }
  w = _EntryList;
  if (w != NULL) {
   ExitEpilog(Self, w);
   return;
  }
  w = _cxq;
  if (w == NULL)
   continue;
  for (;;) {
   ObjectWaiter * u = Atomic::cmpxchg((ObjectWaiter*)NULL, &_cxq, w);
   if (u == w)
    break;
   w = u;
  }
  
  // 策略1
  if (QMode == 1) {
   ObjectWaiter * s = NULL;
   ObjectWaiter * t = w;
   ObjectWaiter * u = NULL;
   while (t != NULL) {
    t->TState = ObjectWaiter::TS_ENTER;
    u = t->_next;
    t->_prev = u;
    t->_next = s;
    s = t;
    t = u;
   }
   _EntryList  = s;
  } else {
   // 策略0，默认策略
   _EntryList = w;
   ObjectWaiter * q = NULL;
   ObjectWaiter * p;
   
   for (p = w; p != NULL; p = p->_next) {
    p->TState = ObjectWaiter::TS_ENTER;
    p->_prev = q;
    q = p;
   }
  }
  
  if (_succ != NULL)
   continue;
   
  w = _EntryList;
  if (w != NULL) {
   ExitEpilog(Self, w);
   return;
  }
 }
}

参考资料

[1]

synchronizer#inflate: https://hg.openjdk.java.net/jdk/jdk11/file/1ddf9a99e4ad/src/hotspot/share/runtime/synchronizer.cpp#l1387