锁：synchronized原理

public class Test {
    private static Object obj = new Object();

    public static void main(String[] args) {
        synchronized (obj) {
            System.out.println("1");
        }
    }

    public synchronized void test() {
        System.out.println("a");
    }
}

ObjectMonitor() {
  _header    = NULL;
  _count     = 0;
  _waiters    = 0，
  _recursions  = 0;  // 线程的重入次数
_object    = NULL; // 存储该monitor的对象
  _owner     = NULL; // 标识拥有该monitor的线程
  _WaitSet    = NULL; // 处于wait状态的线程，会被加入到_WaitSet
  _WaitSetLock  = 0 ;
  _Responsible  = NULL;
  _succ     = NULL;
  _cxq      = NULL; // 多线程竞争锁时的单向列表
  FreeNext    = NULL;
  _EntryList   = NULL; // 处于等待锁block状态的线程，会被加入到该列表
  _SpinFreq   = 0;
  _SpinClock   = 0;
  OwnerIsThread = 0;
}

if (UseBiasedLocking) {//是否用偏向锁
  // Retry fast entry if bias is revoked to avoid unnecessary inflation
  ObjectSynchronizer::fast_enter(h_obj， elem->lock()， true， CHECK);
} else {
  ObjectSynchronizer::slow_enter(h_obj， elem->lock()， CHECK);
}
 assert(Universe::heap()->is_in_reserved_or_null(elem->obj())，
    "must be NULL or an object");

void ATTR ObjectMonitor::enter(TRAPS) {
 // The following code is ordered to check the most common cases first
 // and to reduce RTS->RTO cache line upgrades on SPARC and IA32 processors.
 Thread * const Self = THREAD ;
 void * cur ;
 // 通过CAS操作尝试把monitor的_owner字段设置为当前线程
 cur = Atomic::cmpxchg_ptr (Self， &_owner， NULL) ;
 if (cur == NULL) {
  // Either ASSERT _recursions == 0 or explicitly set _recursions = 0.
  assert (_recursions == 0  ， "invariant") ;
  assert (_owner    == Self， "invariant") ;
  // CONSIDER: set or assert OwnerIsThread == 1
  return ;
}
 // 线程重入，recursions++
 if (cur == Self) {
  // TODO-FIXME: check for integer overflow! BUGID 6557169.
  _recursions ++ ;
  return ;
}
 // 如果当前线程是第一次进入该monitor，设置_recursions为1，_owner为当前线程
if (Self->is_lock_owned ((address)cur)) {
  assert (_recursions == 0， "internal state error");
  _recursions = 1 ;
  // Commute owner from a thread-specific on-stack BasicLockObject address to
  // a full-fledged "Thread *".
  _owner = Self ;
  OwnerIsThread = 1 ;
  return ;
}
 // 省略一些代码
 for (;;) {
  jt->set_suspend_equivalent();
  // cleared by handle_special_suspend_equivalent_condition()
  // or java_suspend_self()
 
// 如果获取锁失败，则等待锁的释放；
  EnterI (THREAD) ;
  if (!ExitSuspendEquivalent(jt)) break ;
  //
  // We have acquired the contended monitor， but while we were
  // waiting another thread suspended us. We don‘t want to enter
  // the monitor while suspended because that would surprise the
  // thread that suspended us.
  //
    _recursions = 0 ;
  _succ = NULL ;
  exit (false， Self) ;
  jt->java_suspend_self();
}
 Self->set_current_pending_monitor(NULL);
}

void ATTR ObjectMonitor::EnterI (TRAPS) {
  Thread * Self = THREAD ;
// Try the lock - TATAS
  if (TryLock (Self) > 0) {
    assert (_succ != Self       , "invariant") ;
    assert (_owner == Self       , "invariant") ;
    assert (_Responsible != Self    , "invariant") ;
    return ;
 }
 
  if (TrySpin (Self) > 0) {
    assert (_owner == Self    , "invariant") ;
    assert (_succ != Self     , "invariant") ;
    assert (_Responsible != Self , "invariant") ;
    return ;
 }//以上代码是在没有获得锁的情况下再次尝试获取锁
 
// 省略部分代码
  // 当前线程被封装成ObjectWaiter对象node，状态设置成ObjectWaiter::TS_CXQ；
  ObjectWaiter node(Self) ;
  Self->_ParkEvent->reset() ;
  node._prev  = (ObjectWaiter *) 0xBAD ;
  node.TState  = ObjectWaiter::TS_CXQ ;
// 通过CAS把node节点push到_cxq列表中
  ObjectWaiter * nxt ;
  for (;;) {
    node._next = nxt = _cxq ;
    if (Atomic::cmpxchg_ptr (&node， &_cxq， nxt) == nxt) break ;
    // Interference - the CAS failed because _cxq changed. Just retry.
    // As an optional optimization we retry the lock.
    if (TryLock (Self) > 0) {
      assert (_succ != Self     ， "invariant") ;
      assert (_owner == Self     ， "invariant") ;
      assert (_Responsible != Self  ， "invariant") ;
      return ;
   }
 }
  // 省略部分代码
  for (;;) {
// 线程在被挂起前做一下挣扎，看能不能获取到锁
    if (TryLock (Self) > 0) break ;
    assert (_owner != Self， "invariant") ;
    if ((SyncFlags & 2) && _Responsible == NULL) {
     Atomic::cmpxchg_ptr (Self， &_Responsible， NULL) ;
   }
    // park self
    if (_Responsible == Self || (SyncFlags & 1)) {
      TEVENT (Inflated enter - park TIMED) ;
      Self->_ParkEvent->park ((jlong) RecheckInterval) ;
      // Increase the RecheckInterval， but clamp the value.
      RecheckInterval *= 8 ;
      if (RecheckInterval > 1000) RecheckInterval = 1000 ;
   } else {
      TEVENT (Inflated enter - park UNTIMED) ;
 // 通过park将当前线程挂起（由于用户和系统的需要，例如，终端用户需要暂停程序研究其执行情况或对其进行修改、OS为了提
高内存利用率需要将暂时不能运行的进程（处于就绪或阻塞队列的进程）调出到磁盘），等待被唤醒
      Self->_ParkEvent->park() ;
   }
    if (TryLock(Self) > 0) break ;
    // 省略部分代码
 }
  // 省略部分代码
}

int ObjectMonitor::TryLock (Thread * Self) {
 for (;;) {
   void * own = _owner ;
   if (own != NULL) return 0 ;
   if (Atomic::cmpxchg_ptr (Self， &_owner， NULL) == NULL) {
    // Either guarantee _recursions == 0 or set _recursions = 0.
    assert (_recursions == 0， "invariant") ;
    assert (_owner == Self， "invariant") ;
    // CONSIDER: set or assert that OwnerIsThread == 1
    return 1 ;
  }
   // The lock had been free momentarily， but we lost the race to the lock.
   // Interference -- the CAS failed.
   // We can either return -1 or retry.
   // Retry doesn‘t make as much sense because the lock was just acquired.
   if (true) return -1 ;
 }
}