Java多线程-对象内置锁（ObjectMonitor）

1、介绍

Monitor是在JVM层对Java并发控制synchronized的重量级锁的实现。通过ObjectMonitor来实现并发的锁控制。同时也是Java基础对象Object的wait,nofity方法的底层支持实现。

2、对象模型

2.1 数据结构图

ObjectMonitor整体上可以分为两部分，一部分是是这个监控对象的基本信息表示当前锁的实时状态，一部分表示各种情况下需要获取锁的排队信息。如下图所示：

 

基本信息

1 header

用来保存锁对象的mark word的值。因为object里面已经不保存mark word的原来的值了，保存的是ObjectMonitor对象的地址信息。当所有线程都完成了之后，需要销毁掉ObjectMonitor的时候需要将原有的header里面的值重新复制到mark word中来。

2 object

指向的是对象的地址信息，方便通过ObjectMonitor来访问对应的锁对象。

3 owner

指向的是当前获得线程的地址，用来判断当前锁是被哪个线程持有。

排队信息

1cxq

线程刚进来的时候没有获取到锁的时候，在当前的排队队列。

2waitSet

是指已经获取得一次锁了，对象调用了wait方法，讲当前线程挂起了就进入了等待队列。等待时间到期的时候唤醒，或者其他线程唤醒。

3 entryList

是队列用来获取锁的缓冲区，用来将cxq和waitSet中的数据 移动到entryList进行排队。这个统一获取锁的入口。一般是cxq 或者waitSet数据复制过来进行统一排队。

2.2 ObjectMonitor 的源代码

ObjectMonitor() {
  _header       = NULL;
  _count        = 0;
  _waiters      = 0,
  _recursions   = 0;
  _object       = NULL;
  _owner        = NULL;
  _WaitSet      = NULL;
  _WaitSetLock  = 0 ;
  _Responsible  = NULL ;
  _succ         = NULL ;
  //多线程竞争锁进入时的单向链表
  _cxq          = NULL ;
  FreeNext      = NULL ;
  //_owner从该双向循环链表中唤醒线程结点，_EntryList是第一个节点
  _EntryList    = NULL ;
  _SpinFreq     = 0 ;
  _SpinClock    = 0 ;
  OwnerIsThread = 0 ;
  _previous_owner_tid = 0;
}

2.3 ObjectWaiter源代码

下面是排队对象ObjectWaiter的源代码的信息

class ObjectWaiter : public StackObj {
 public:
  enum TStates { TS_UNDEF, TS_READY, TS_RUN, TS_WAIT, TS_ENTER, TS_CXQ } ;
  enum Sorted  { PREPEND, APPEND, SORTED } ;
  ObjectWaiter * volatile _next;
  ObjectWaiter * volatile _prev;
  //等待的线程
  Thread*       _thread;
  jlong         _notifier_tid;
  ParkEvent *   _event;
  volatile int  _notified ;
  volatile TStates TState ;
  Sorted        _Sorted ;           // List placement disposition
  bool          _active ;           // Contention monitoring is enabled
};

3、核心方法

3.1 TryLock

int ObjectMonitor::TryLock (Thread * Self) {
   for (;;) {
      void * own = _owner ;
      //已经有线程获取到锁了 直接返回
      if (own != NULL){
          return 0 ;
       }
       //获取锁成功
      if (Atomic::cmpxchg_ptr (Self, &_owner, NULL) == NULL) {
         return 1 ;
      }
      if (true) return -1 ;
   }
}

通过上面代码我们可以详细的获取锁的逻辑，判断当前的监视器对象是否已经为空了，如果不为空说明已经有线程拿到锁了直接结束。当为空闲的尝试设置当前线程来获取锁，成功了直接返回1 。通过上面代码看总体上只做一次尝试，并不会多次尝试。

3.3 try_enter

try_enter 的方法是尝试获取当前锁对象 ，在已经拿过一次锁对象了之后，二次重新进入锁的场景使用。整个过程是只做一次尝试，不论成功失败都只执行一次。

bool ObjectMonitor::try_enter(Thread* THREAD) {
  if (THREAD != _owner) {
     //判断当前线程是否已经活动锁
    if (THREAD->is_lock_owned ((address)_owner)) {
       _owner = THREAD ;
       _recursions = 1 ;
       OwnerIsThread = 1 ;
       return true;
    }
    //设置当前线程为当前线程
    if (Atomic::cmpxchg_ptr (THREAD, &_owner, NULL) != NULL) {
      return false;
    }
    return true;
  } else {
    _recursions++;
    return true;
  }
}

通过上述逻辑我们可以看到当前的线程是否已经持有了这个锁对象，如果持有了直接返回，如果没有持有尝试持有下。

3.3 enter

enter方法是整个获取到锁逻辑的核心实现，核心的思想是在整个链路中尽一切可能的获取到锁，如果实在获取不到情况进入等待队列进行等待。整体思路如下：

1 尝试获取获取获取锁，获取到成功直接返回。这个时刻整个等待成不是最低的。

2 判断自己是否已经拿到锁了，如果前面当前线程已经获取到锁了，也就直接返回。从这这里看ObjectMonitor是可以重入的。

3 通过自旋多次尝试获取到锁的信息，如果获取到直接返回。满满的求生生欲望，避免自己加入到等待。

4 通过自旋转调用EnterI方法让自己加入到cxq等待队列。一旦调用成功了整个线程就是park了，交出了执行状态等待唤醒了。

5 整个获取到锁之后就调用exit推出了。

void ATTR ObjectMonitor::enter(TRAPS) {
  //定义当前线程变量
  Thread * const Self = THREAD ;
  void * cur ;

  //1 如果没有人持有这个monitor 直接将自己设置成持有者
  cur = Atomic::cmpxchg_ptr (Self, &_owner, NULL) ;
  if (cur == NULL) {
     return ;
  }
  //2 如果已经持有了 计数+1
  if (cur == Self) {
     _recursions ++ ;
     return ;
  }
  //判断当前线程的地址
  if (Self->is_lock_owned ((address)cur)) {
    _recursions = 1 ;
    _owner = Self ;
    OwnerIsThread = 1 ;
    return ;
  }
  
  Self->_Stalled = intptr_t(this) ;
  //3 如果允许自旋，通过自旋转来获取锁的信息
  if (Knob_SpinEarly && TrySpin (Self) > 0) {
     assert (((oop)(object()))->mark() == markOopDesc::encode(this), "invariant") ;
     Self->_Stalled = 0 ;
     return ;
  }
  //前面的尝试都失败了就开始正式的进入到等待队列进行等待了
  JavaThread * jt = (JavaThread *) Self ;
  //增加等待计数
  Atomic::inc_ptr(&_count);
  { 
    //4 自旋进入到等待队列中来
    for (;;) {
      jt->set_suspend_equivalent();
      //重点是加入等待队列中来
      EnterI (THREAD) ;
      _recursions = 0 ;
      _succ = NULL ;
      //5 推出机制
      exit (false, Self) ;
      jt->java_suspend_self();
    }
    Self->set_current_pending_monitor(NULL);
  }
  //减少等待计数
  Atomic::dec_ptr(&_count);
  Self->_Stalled = 0 ;
}

3.4 EnterI

EnterI 是整个进入等待队列的核心实现，核心的思想是在尽最后可能的获取到锁，如果实在不行加入到_cxq的等待队列，加入队列成功后将当前线程挂起。整体思路如下：

1 尝试通过TryLock尝试获取下对象锁的信息。

2 尝试通过自旋锁来获取锁的信息，这也是最后一次尝试了。实在不行就只能等待了。

3 构造等待节点对象，开始进行等待了。

4 将当前线程的等待对象加入到能对队列_cxq排队队列中来

5 每个执行的循环周期都会经历尝试获取锁，获取不到将自己挂起park的过程。中间有个小插曲尝试将自己设置成整个对象的维护线程（_Responsiblew），是防止获取锁的所有线程都进入了等待队列，没有人能通知其他线程进行拿锁的操作。

void ATTR ObjectMonitor::EnterI (TRAPS) {
    Thread * Self = THREAD ;
    //1 尝试获取当前的锁对象
    if (TryLock (Self) > 0) {
        return ;
    }
    DeferredInitialize () ;
    //2 尝试通过自旋获取到锁的机制
    if (TrySpin (Self) > 0) {
        return ;
    }
     //3 构造一个 ObjectWaiter对象 也就是等待对象
    ObjectWaiter node(Self) ;
    Self->_ParkEvent->reset() ;
    node._prev   = (ObjectWaiter *) 0xBAD ;
    node.TState  = ObjectWaiter::TS_CXQ ;

    //4 加入到能对队列_cxq中来
    ObjectWaiter * nxt ;
    for (;;) {
        node._next = nxt = _cxq ;
        //添加完成直接返回
        if (Atomic::cmpxchg_ptr (&node, &_cxq, nxt) == nxt) break ;
        //顺便捎带加入下锁 看看是否成功
        if (TryLock (Self) > 0) {
            return ;
        }
    }

    //如果没有其他线程 将当前线程设置成负责线程 以方便后面对象回收
    if ((SyncFlags & 16) == 0 && nxt == NULL && _EntryList == NULL) {
        Atomic::cmpxchg_ptr (Self, &_Responsible, NULL) ;
    }
    
    int nWakeups = 0 ;
    int RecheckInterval = 1 ;
    //5 循环进入等待和唤醒的情况，这个代码需要仔细研读
    for (;;) {
        //尝试加个锁看看是否有运气
        if (TryLock (Self) > 0) break ;
        if ((SyncFlags & 2) && _Responsible == NULL) {
           Atomic::cmpxchg_ptr (Self, &_Responsible, NULL) ;
        }
        //防止所有的线程都进入死等的情况，这样就会出现线程死锁
        if (_Responsible == Self || (SyncFlags & 1)) {
            //过一段时间就起来看看 
            Self->_ParkEvent->park ((jlong) RecheckInterval) ;
            RecheckInterval *= 8 ;
            if (RecheckInterval > 1000) RecheckInterval = 1000 ;
        } else {
            Self->_ParkEvent->park() ;
        }
       //尝试加个锁看看是否有运气
        if (TryLock(Self) > 0) break ;
        ++ nWakeups ;
        // 自旋试下 是否成功
        if ((Knob_SpinAfterFutile & 1) && TrySpin (Self) > 0) break ;
        if ((Knob_ResetEvent & 1) && Self->_ParkEvent->fired()) {
           Self->_ParkEvent->reset() ;
           OrderAccess::fence() ;
        }
        if (_succ == Self) _succ = NULL ;
    }
    //已经获取到了锁，讲当前节点从等待队列中解除
    UnlinkAfterAcquire (Self, &node) ;
    return ;
}

3.5 exit

线程执行同步方法或代码块结束之后，会调用exit方法将当前线程从锁对象中移除，并尝试唤醒启动的线程来获取锁的过程。核心要点有两个，一个是将当前线程释放，这个很好理解就把_owner字段中线程值设为空就好了。另一个是唤醒其他线程，这个就涉及到相关的策略，因为前面他有一个排队队列_cxq，还有一个_EntryList，到底从哪里优先去取。提供了四种策略：

QMode=2 的时候 优先从_cxq唤醒，执行过程如下图：

QMode=3 的时候 _cxq中的数据加入到_EntryList尾部中来 然后从_EntryList开始获取

 

 QMode=4的时候 _cxq中的数据加入到_EntryList前面来 然后从_EntryList开始获取

 

QMode=1 的时候 这个是默认策略 优先从_EntryList 中获取 如果_EntryList为空的情况，把_cxq进行队列反转然后从_cxq获取

整个策略本质上是考虑公平性与吞吐效率的考量。

void ATTR ObjectMonitor::exit(bool not_suspended, TRAPS) {
   Thread * Self = THREAD ;
   //1判断当前线程是否是锁的线程
   if (THREAD != _owner) {
     if (THREAD->is_lock_owned((address) _owner)) {
       _owner = THREAD ;
       _recursions = 0 ;
       OwnerIsThread = 1 ;
     } 
   }
   //重入锁的次数减1
   if (_recursions != 0) {
     _recursions--;        // this is simple recursive enter
     return ;
   }

   // Invariant: after setting Responsible=null an thread must execute
   // a MEMBAR or other serializing instruction before fetching EntryList|cxq.
   if ((SyncFlags & 4) == 0) {
      _Responsible = NULL ;
   }
   for (;;) {
    
      if (Knob_ExitPolicy == 0) {
         OrderAccess::release_store_ptr (&_owner, NULL) ;   // drop the lock
         OrderAccess::storeload() ;  
         //没有人需要获取锁了直接返回
         if ((intptr_t(_EntryList)|intptr_t(_cxq)) == 0 || _succ != NULL) {
            return ;
         }
         //当锁已经被其他线程抢占了 直接推出就好了
         if (Atomic::cmpxchg_ptr (THREAD, &_owner, NULL) != NULL) {
            return ;
         }
      } else {
         if ((intptr_t(_EntryList)|intptr_t(_cxq)) == 0 || _succ != NULL) {
            OrderAccess::release_store_ptr (&_owner, NULL) ;   // drop the lock
            OrderAccess::storeload() ;
            if (_cxq == NULL || _succ != NULL) {
                return ;
            }
            if (Atomic::cmpxchg_ptr (THREAD, &_owner, NULL) != NULL) {
               return ;
            }
         } 
      }
      
      ObjectWaiter * w = NULL ;
      int QMode = Knob_QMode ;

      //当QMode=2的时候 优先从_cxq唤醒
      if (QMode == 2 && _cxq != NULL) {
          w = _cxq ;
          assert (w != NULL, "invariant") ;
          assert (w->TState == ObjectWaiter::TS_CXQ, "Invariant") ;
          ExitEpilog (Self, w) ;
          return ;
      }
        //当QMode=3的时候 讲_cxq中的数据加入到_EntryList尾部中来 然后从_EntryList开始获取
      if (QMode == 3 && _cxq != NULL) {
          w = _cxq ;
          for (;;) {
             ObjectWaiter * u = (ObjectWaiter *) Atomic::cmpxchg_ptr (NULL, &_cxq, w) ;
             if (u == w) break ;
             w = u ;
          }
          assert (w != NULL              , "invariant") ;

          ObjectWaiter * q = NULL ;
          ObjectWaiter * p ;
          for (p = w ; p != NULL ; p = p->_next) {
              guarantee (p->TState == ObjectWaiter::TS_CXQ, "Invariant") ;
              p->TState = ObjectWaiter::TS_ENTER ;
              p->_prev = q ;
              q = p ;
          }

         //讲_cxq数据加入到_EntryList的队列中来
          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 ;
          }

     
      }
      //当QMode=4的时候 讲_cxq中的数据加入到_EntryList前面来 然后从_EntryList开始获取
      if (QMode == 4 && _cxq != NULL) {
          w = _cxq ;
          for (;;) {
             assert (w != NULL, "Invariant") ;
             ObjectWaiter * u = (ObjectWaiter *) Atomic::cmpxchg_ptr (NULL, &_cxq, w) ;
             if (u == w) break ;
             w = u ;
          }
 
          //批量修改状态标志改成TS_ENTER
          ObjectWaiter * q = NULL ;
          ObjectWaiter * p ;
          for (p = w ; p != NULL ; p = p->_next) {
              p->TState = ObjectWaiter::TS_ENTER ;
              p->_prev = q ;
              q = p ;
          }

          //插到原有的_EntryList前面 从员_EntryList中获取
          if (_EntryList != NULL) {
              q->_next = _EntryList ;
              _EntryList->_prev = q ;
          }
          _EntryList = w ;

          // Fall thru into code that tries to wake a successor from EntryList
      }

      w = _EntryList  ;
      if (w != NULL) {
          assert (w->TState == ObjectWaiter::TS_ENTER, "invariant") ;
          ExitEpilog (Self, w) ;
          return ;
      }

      // If we find that both _cxq and EntryList are null then just
      // re-run the exit protocol from the top.
      w = _cxq ;
      if (w == NULL) continue ;

      //默认的策略
      for (;;) {
          assert (w != NULL, "Invariant") ;
          ObjectWaiter * u = (ObjectWaiter *) Atomic::cmpxchg_ptr (NULL, &_cxq, w) ;
          if (u == w) break ;
          w = u ;
      }
      //将cxq排队队列进行翻转。
      if (QMode == 1) {
         // QMode == 1 : drain cxq to EntryList, reversing order
         // We also reverse the order of the list.
         ObjectWaiter * s = NULL ;
         ObjectWaiter * t = w ;
         ObjectWaiter * u = NULL ;
         while (t != NULL) {
             guarantee (t->TState == ObjectWaiter::TS_CXQ, "invariant") ;
             t->TState = ObjectWaiter::TS_ENTER ;
             u = t->_next ;
             t->_prev = u ;
             t->_next = s ;
             s = t;
             t = u ;
         }
         _EntryList  = s ;
         assert (s != NULL, "invariant") ;
      } else {
         // QMode == 0 or QMode == 2
         _EntryList = w ;
         ObjectWaiter * q = NULL ;
         ObjectWaiter * p ;
         for (p = w ; p != NULL ; p = p->_next) {
             guarantee (p->TState == ObjectWaiter::TS_CXQ, "Invariant") ;
             p->TState = ObjectWaiter::TS_ENTER ;
             p->_prev = q ;
             q = p ;
         }
      }
      if (_succ != NULL) continue;

      w = _EntryList  ;
      if (w != NULL) {
          guarantee (w->TState == ObjectWaiter::TS_ENTER, "invariant") ;
          ExitEpilog (Self, w) ;
          return ;
      }
   }
}