一.java反编译工具

1.1 jdk自带的反编译工具

  1. 在target包中找到需要反编译的类右击打开控制台,然后在控制台中输入javap -c -v 类名.class

Synchronized源码解读 - 图1

1.2使用ideal插件

  1. 1.2.1安装插

Synchronized源码解读 - 图2

  1. 1.2.2 构建项目

Synchronized源码解读 - 图3

  1. 1.2.3查看字节码文件

Synchronized源码解读 - 图4
Synchronized源码解读 - 图5

二、synchronized 实现原理

众所周知 synchronized 锁在 Java 中经常使用它的源码是 C++ 实现的，它的实现原理是怎样的呢？本文以 OpenJDK 8 为例探究以下内容。

  • synchronized 是如何工作的
  • synchronized 锁升级过程
  • 重量级锁的队列之间协作过程和策略

对象头

对象头的内容非常多这里我们只做简单介绍以引出后文。在 JVM 中对象布局分为三块区域：

  • 对象头
  • 实例数据
  • 对齐填充

image.png
当线程访问同步块时首先需要获得锁并把相关信息存储在对象头中。所以 wait、notify、notifyAll 这些方法为什么被设计在 Object 中或许你已经找到答案了。
Hotspot 有两种对象头：

  • 数组类型，使用 arrayOopDesc 来描述对象头
  • 其它，使用 instanceOopDesc 来描述对象头

对象头由两部分组成

  • Mark Word：存储自身的运行时数据，例如 HashCode、GC 年龄、锁相关信息等内容。
  • Klass Pointer：类型指针指向它的类元数据的指针。

64 位虚拟机 Mark Word 是 64bit 其结构如下：
image.png在 JDK 6 中虚拟机团队对锁进行了重要改进，优化了其性能引入了 偏向锁、轻量级锁、适应性自旋、锁消除、锁粗化等实现，其中 锁消除和锁粗化本文不做详细讨论其余内容我们将对其进行逐一探究。
总体上来说锁状态升级流程如下：

image.png

偏向锁

流程

当线程访问同步块并获取锁时处理流程如下：

  1. 检查 mark word 的线程 id 。
  2. 如果为空则设置 CAS 替换当前线程 id。如果替换成功则获取锁成功，如果失败则撤销偏向锁。
  3. 如果不为空则检查 线程 id为是否为本线程。如果是则获取锁成功，如果失败则撤销偏向锁。

持有偏向锁的线程以后每次进入这个锁相关的同步块时，只需比对一下 mark word 的线程 id 是否为本线程，如果是则获取锁成功。
如果发生线程竞争发生 2、3 步失败的情况则需要撤销偏向锁。

偏向锁的撤销

  1. 偏向锁的撤销动作必须等待全局安全点
  2. 暂停拥有偏向锁的线程，判断锁对象是否处于被锁定状态

  3. 撤销偏向锁恢复到无锁（标志位为 01）或轻量级锁（标志位为 00）的状态

    优点

    只有一个线程执行同步块时进一步提高性能，适用于一个线程反复获得同一锁的情况。偏向锁可以提高带有同步但无竞争的程序性能。

    缺点

    如果存在竞争会带来额外的锁撤销操作。

    轻量级锁

    加锁

    多个线程竞争偏向锁导致偏向锁升级为轻量级锁

  4. JVM 在当前线程的栈帧中创建 Lock Reocrd，并将对象头中的 Mark Word 复制到 Lock Reocrd 中。（Displaced Mark Word）

  5. 线程尝试使用 CAS 将对象头中的 Mark Word 替换为指向 Lock Reocrd 的指针。如果成功则获得锁，如果失败则先检查对象的 Mark Word 是否指向当前线程的栈帧如果是则说明已经获取锁，否则说明其它线程竞争锁则膨胀为重量级锁。

    解锁

  6. 使用 CAS 操作将 Mark Word 还原

  7. 如果第 1 步执行成功则释放完成
  8. 如果第 1 步执行失败则膨胀为重量级锁。

    优点

    其性能提升的依据是对于绝大部分的锁在整个生命周期内都是不会存在竞争。在多线程交替执行同步块的情况下，可以避免重量级锁引起的性能消耗。

    缺点

    在有多线程竞争的情况下轻量级锁增加了额外开销。

    自旋锁

    自旋是一种获取锁的机制并不是一个锁状态。在膨胀为重量级锁的过程中或重入时会多次尝试自旋获取锁以避免线程唤醒的开销，但是它会占用 CPU 的时间因此如果同步代码块执行时间很短自旋等待的效果就很好，反之则浪费了 CPU 资源。默认情况下自旋次数是 10 次用户可以使用参数 -XX : PreBlockSpin 来更改。那么如何优化来避免此情况发生呢？我们来看适应性自旋。

    适应性自旋锁

    JDK 6 引入了自适应自旋锁，意味着自旋的次数不在固定，而是由前一次在同一个锁上的自旋时间及锁的拥有者的状态来决定。如果对于某个锁很少自旋成功那么以后有可能省略掉自旋过程以避免资源浪费。有了自适应自旋随着程序运行和性能监控信息的不断完善，虚拟机对程序锁的状况预测就会越来越准确，虛拟机就会变得越来越“聪明”了。

    优点

    竞争的线程不会阻塞挂起，提高了程序响应速度。避免重量级锁引起的性能消耗。

    缺点

    如果线程始终无法获取锁，自旋消耗 CPU 最终会膨胀为重量级锁。

    重量级锁

    在重量级锁中没有竞争到锁的对象会 park 被挂起，退出同步块时 unpark 唤醒后续线程。唤醒操作涉及到操作系统调度会有额外的开销。
    ObjectMonitor 中包含一个同步队列（由 _cxq 和 _EntryList 组成）一个等待队列（ _WaitSet ）。
  • 被notify或 notifyAll 唤醒时根据 policy 策略选择加入的队列（policy 默认为 0）
  • 退出同步块时根据 QMode 策略来唤醒下一个线程（QMode 默认为 0）

这里稍微提及一下管程这个概念。synchronized 关键字及 wait、notify、notifyAll 这三个方法都是管程的组成部分。可以说管程就是一把解决并发问题的万能钥匙。有两大核心问题管程都是能够解决的：

  • 互斥：即同一时刻只允许一个线程访问共享资源；
  • 同步：即线程之间如何通信、协作。

synchronized 的 monitor锁机制和 JDK 并发包中的 AQS 是很相似的，只不过 AQS 中是一个同步队列多个等待队列。熟悉 AQS 的同学可以拿来做个对比。

队列协作流程图

image.png

源码分析

在 HotSpot 中 monitor 是由 ObjectMonitor 实现的。其源码是用 c++来实现的源文件是 ObjectMonitor.hpp 主要数据结构如下所示：

  1. ObjectMonitor() {
  2.     _header       = NULL;
  3.     _count        = 0;
  4.     _waiters      = 0,       // 等待中的线程数
  5.     _recursions   = 0;       // 线程重入次数
  6.     _object       = NULL;    // 存储该 monitor 的对象
  7.     _owner        = NULL;    // 指向拥有该 monitor 的线程
  8.     _WaitSet      = NULL;    // 等待线程 双向循环链表_WaitSet 指向第一个节点
  9.     _WaitSetLock  = 0 ;
  10.     _Responsible  = NULL ;
  11.     _succ         = NULL ;
  12.     _cxq          = NULL ;   // 多线程竞争锁时的单向链表
  13.     FreeNext      = NULL ;
  14.     _EntryList    = NULL ;   // _owner 从该双向循环链表中唤醒线程，
  15.     _SpinFreq     = 0 ;
  16.     _SpinClock    = 0 ;
  17.     OwnerIsThread = 0 ;
  18.     _previous_owner_tid = 0; // 前一个拥有此监视器的线程 ID
  19.   }
  1. _owner：初始时为 NULL。当有线程占有该 monitor 时 owner 标记为该线程的 ID。当线程释放 monitor 时 owner 恢复为 NULL。owner 是一个临界资源 JVM 是通过 CAS 操作来保证其线程安全的。
  2. _cxq：竞争队列所有请求锁的线程首先会被放在这个队列中（单向）。_cxq 是一个临界资源 JVM 通过 CAS 原子指令来修改_cxq 队列。
  3. 每当有新来的节点入队，它的 next 指针总是指向之前队列的头节点，而_cxq 指针会指向该新入队的节点，所以是后来居上。
  4. _EntryList： _cxq 队列中有资格成为候选资源的线程会被移动到该队列中。
  5. _WaitSet: 等待队列因为调用 wait 方法而被阻塞的线程会被放在该队列中。

monitor 竞争过程

  1. 通过 CAS 尝试把 monitor 的 owner 字段设置为当前线程。
  2. 如果设置之前的 owner 指向当前线程，说明当前线程再次进入 monitor，即重入锁执行 recursions ++ , 记录重入的次数。
  3. 如果当前线程是第一次进入该 monitor, 设置 recursions 为 1,_owner 为当前线程，该线程成功获得锁并返回。
  4. 如果获取锁失败，则等待锁的释放。

执行 monitorenter 指令时 调用以下代码

  1. IRT_ENTRY_NO_ASYNC(void, InterpreterRuntime::monitorenter(JavaThread* thread, BasicObjectLock* elem))
  2. #ifdef ASSERT
  3.   thread->last_frame().interpreter_frame_verify_monitor(elem);
  4. #endif
  5.   if (PrintBiasedLockingStatistics) {
  6.     Atomic::inc(BiasedLocking::slow_path_entry_count_addr());
  7.   }
  8.   Handle h_obj(thread, elem->obj());
  9.   assert(Universe::heap()->is_in_reserved_or_null(h_obj()),"must be NULL or an object");
  10. // 是否使用偏向锁  JVM 启动时设置的偏向锁-XX:-UseBiasedLocking=false/true
  11.   if (UseBiasedLocking) {
  12.     // Retry fast entry if bias is revoked to avoid unnecessary inflation
  13.     ObjectSynchronizer::fast_enter(h_obj, elem->lock(), true, CHECK);
  14.   } else {
  15.       // 轻量级锁
  16.     ObjectSynchronizer::slow_enter(h_obj, elem->lock(), CHECK);
  17.   }
  18.   assert(Universe::heap()->is_in_reserved_or_null(elem->obj()),
  19.          "must be NULL or an object");
  20. #ifdef ASSERT
  21.   thread->last_frame().interpreter_frame_verify_monitor(elem);
  22. #endif
  23. IRT_END

slow_enter 方法主要是轻量级锁的一些操作，如果操作失败则会膨胀为重量级锁，过程前面已经描述比较清楚此处不在赘述。enter 方法则为重量级锁的入口源码如下

  1. void ATTR ObjectMonitor::enter(TRAPS) {
  2.   Thread * const Self = THREAD ;
  3.   void * cur ;
  4.   // 省略部分代码
  6.   // 通过 CAS 操作尝试把 monitor 的_owner 字段设置为当前线程
  7.   cur = Atomic::cmpxchg_ptr (Self, &_owner, NULL) ;
  8.   if (cur == NULL) {
  9.      assert (_recursions == 0   , "invariant") ;
  10.      assert (_owner      == Self, "invariant") ;
  11.      return ;
  12.   }
  14.  // 线程重入，recursions++
  15.   if (cur == Self) {
  16.      _recursions ++ ;
  17.      return ;
  18.   }
  20.     // 如果当前线程是第一次进入该 monitor, 设置_recursions 为 1,_owner 为当前线程
  21.   if (Self->is_lock_owned ((address)cur)) {
  22.     assert (_recursions == 0, "internal state error");
  23.     _recursions = 1 ;
  24.     _owner = Self ;
  25.     OwnerIsThread = 1 ;
  26.     return ;
  27.   }
  29.     for (;;) {
  30.       jt->set_suspend_equivalent();
  31.         // 如果获取锁失败，则等待锁的释放；
  32.       EnterI (THREAD) ;
  34.       if (!ExitSuspendEquivalent(jt)) break ;
  35.           _recursions = 0 ;
  36.       _succ = NULL ;
  37.       exit (false, Self) ;
  39.       jt->java_suspend_self();
  40.     }
  41.     Self->set_current_pending_monitor(NULL);
  42.   }
  43. }

monitor 等待

  1. 当前线程被封装成 ObjectWaiter 对象 node，状态设置成 ObjectWaiter::TS_CXQ。
  2. for 循环通过 CAS 把 node 节点 push 到_cxq列表中，同一时刻可能有多个线程把自己的 node 节点 push 到_cxq列表中。
  3. node 节点 push 到_cxq 列表之后，通过自旋尝试获取锁，如果还是没有获取到锁则通过 park 将当前线程挂起等待被唤醒。
  4. 当该线程被唤醒时会从挂起的点继续执行，通过 ObjectMonitor::TryLock 尝试获取锁。
  1. // 省略部分代码
  2. void ATTR ObjectMonitor::EnterI (TRAPS) {
  3.     Thread * Self = THREAD ;
  4.     assert (Self->is_Java_thread(), "invariant") ;
  5.     assert (((JavaThread *) Self)->thread_state() == _thread_blocked   , "invariant") ;
  7.     // Try lock 尝试获取锁
  8.     if (TryLock (Self) > 0) {
  9.         assert (_succ != Self              , "invariant") ;
  10.         assert (_owner == Self             , "invariant") ;
  11.         assert (_Responsible != Self       , "invariant") ;
  12.         // 如果获取成功则退出，避免 park unpark 系统调度的开销
  13.         return ;
  14.     }
  16.     // 自旋获取锁
  17.     if (TrySpin(Self) > 0) {
  18.         assert (_owner == Self, "invariant");
  19.         assert (_succ != Self, "invariant");
  20.         assert (_Responsible != Self, "invariant");
  21.         return;
  22.     }
  24.     // 当前线程被封装成 ObjectWaiter 对象 node, 状态设置成 ObjectWaiter::TS_CXQ
  25.     ObjectWaiter node(Self) ;
  26.     Self->_ParkEvent->reset() ;
  27.     node._prev   = (ObjectWaiter *) 0xBAD ;
  28.     node.TState  = ObjectWaiter::TS_CXQ ;
  30.     // 通过 CAS 把 node 节点 push 到_cxq 列表中
  31.     ObjectWaiter * nxt ;
  32.     for (;;) {
  33.         node._next = nxt = _cxq ;
  34.         if (Atomic::cmpxchg_ptr (&node, &_cxq, nxt) == nxt) break ;
  36.         // 再次 tryLock
  37.         if (TryLock (Self) > 0) {
  38.             assert (_succ != Self         , "invariant") ;
  39.             assert (_owner == Self        , "invariant") ;
  40.             assert (_Responsible != Self  , "invariant") ;
  41.             return ;
  42.         }
  43.     }
  45.     for (;;) {
  46.         // 本段代码的主要思想和 AQS 中相似可以类比来看
  47.         // 再次尝试
  48.         if (TryLock (Self) > 0) break ;
  49.         assert (_owner != Self, "invariant") ;
  51.         if ((SyncFlags & 2) && _Responsible == NULL) {
  52.            Atomic::cmpxchg_ptr (Self, &_Responsible, NULL) ;
  53.         }
  55.         // 满足条件则 park self
  56.         if (_Responsible == Self || (SyncFlags & 1)) {
  57.             TEVENT (Inflated enter - park TIMED) ;
  58.             Self->_ParkEvent->park ((jlong) RecheckInterval) ;
  59.             // Increase the RecheckInterval, but clamp the value.
  60.             RecheckInterval *= 8 ;
  61.             if (RecheckInterval > 1000) RecheckInterval = 1000 ;
  62.         } else {
  63.             TEVENT (Inflated enter - park UNTIMED) ;
  64.             // 通过 park 将当前线程挂起，等待被唤醒
  65.             Self->_ParkEvent->park() ;
  66.         }
  68.         if (TryLock(Self) > 0) break ;
  69.         // 再次尝试自旋
  70.         if ((Knob_SpinAfterFutile & 1) && TrySpin(Self) > 0) break;
  71.     }
  72.     return ;
  73. }

monitor 释放

当某个持有锁的线程执行完同步代码块时，会释放锁并 unpark 后续线程（由于篇幅只保留重要代码）。

  1. void ATTR ObjectMonitor::exit(bool not_suspended, TRAPS) {
  2.    Thread * Self = THREAD ;
  4.    if (_recursions != 0) {
  5.      _recursions--;        // this is simple recursive enter
  6.      TEVENT (Inflated exit - recursive) ;
  7.      return ;
  8.    }
  10.       ObjectWaiter * w = NULL ;
  11.       int QMode = Knob_QMode ;
  13.     // 直接绕过 EntryList 队列，从 cxq 队列中获取线程用于竞争锁
  14.       if (QMode == 2 && _cxq != NULL) {
  15.           w = _cxq ;
  16.           assert (w != NULL, "invariant") ;
  17.           assert (w->TState == ObjectWaiter::TS_CXQ, "Invariant") ;
  18.           ExitEpilog (Self, w) ;
  19.           return ;
  20.       }
  21.     // cxq 队列插入 EntryList 尾部
  22.       if (QMode == 3 && _cxq != NULL) {
  23.           w = _cxq ;
  24.           for (;;) {
  25.              assert (w != NULL, "Invariant") ;
  26.              ObjectWaiter * u = (ObjectWaiter *) Atomic::cmpxchg_ptr (NULL, &_cxq, w) ;
  27.              if (u == w) break ;
  28.              w = u ;
  29.           }
  30.           ObjectWaiter * q = NULL ;
  31.           ObjectWaiter * p ;
  32.           for (p = w ; p != NULL ; p = p->_next) {
  33.               guarantee (p->TState == ObjectWaiter::TS_CXQ, "Invariant") ;
  34.               p->TState = ObjectWaiter::TS_ENTER ;
  35.               p->_prev = q ;
  36.               q = p ;
  37.           }
  39.           ObjectWaiter * Tail ;
  40.           for (Tail = _EntryList ; Tail != NULL && Tail->_next != NULL ; Tail = Tail->_next) ;
  41.           if (Tail == NULL) {
  42.               _EntryList = w ;
  43.           } else {
  44.               Tail->_next = w ;
  45.               w->_prev = Tail ;
  46.           }
  47.       }
  49.     // cxq 队列插入到_EntryList 头部
  50.       if (QMode == 4 && _cxq != NULL) {
  51.           // 把 cxq 队列放入 EntryList
  52.           // 此策略确保最近运行的线程位于 EntryList 的头部
  53.           w = _cxq ;
  54.           for (;;) {
  55.              assert (w != NULL, "Invariant") ;
  56.              ObjectWaiter * u = (ObjectWaiter *) Atomic::cmpxchg_ptr (NULL, &_cxq, w) ;
  57.              if (u == w) break ;
  58.              w = u ;
  59.           }
  60.           assert (w != NULL              , "invariant") ;
  62.           ObjectWaiter * q = NULL ;
  63.           ObjectWaiter * p ;
  64.           for (p = w ; p != NULL ; p = p->_next) {
  65.               guarantee (p->TState == ObjectWaiter::TS_CXQ, "Invariant") ;
  66.               p->TState = ObjectWaiter::TS_ENTER ;
  67.               p->_prev = q ;
  68.               q = p ;
  69.           }
  71.           if (_EntryList != NULL) {
  72.               q->_next = _EntryList ;
  73.               _EntryList->_prev = q ;
  74.           }
  75.           _EntryList = w ;
  76.       }
  78.       w = _EntryList  ;
  79.       if (w != NULL) {
  80.           assert (w->TState == ObjectWaiter::TS_ENTER, "invariant") ;
  81.           ExitEpilog (Self, w) ;
  82.           return ;
  83.       }
  84.       w = _cxq ;
  85.       if (w == NULL) continue ;
  87.       for (;;) {
  88.           assert (w != NULL, "Invariant") ;
  89.           ObjectWaiter * u = (ObjectWaiter *) Atomic::cmpxchg_ptr (NULL, &_cxq, w) ;
  90.           if (u == w) break ;
  91.           w = u ;
  92.       }
  94.       if (QMode == 1) {
  95.          // QMode == 1 : 把 cxq 倾倒入 EntryList 逆序
  96.          ObjectWaiter * s = NULL ;
  97.          ObjectWaiter * t = w ;
  98.          ObjectWaiter * u = NULL ;
  99.          while (t != NULL) {
  100.              guarantee (t->TState == ObjectWaiter::TS_CXQ, "invariant") ;
  101.              t->TState = ObjectWaiter::TS_ENTER ;
  102.              u = t->_next ;
  103.              t->_prev = u ;
  104.              t->_next = s ;
  105.              s = t;
  106.              t = u ;
  107.          }
  108.          _EntryList  = s ;
  109.          assert (s != NULL, "invariant") ;
  110.       } else {
  111.          // QMode == 0 or QMode == 2
  112.          _EntryList = w ;
  113.          ObjectWaiter * q = NULL ;
  114.          ObjectWaiter * p ;
  115.           // 将单向链表构造成双向环形链表；
  116.          for (p = w ; p != NULL ; p = p->_next) {
  117.              guarantee (p->TState == ObjectWaiter::TS_CXQ, "Invariant") ;
  118.              p->TState = ObjectWaiter::TS_ENTER ;
  119.              p->_prev = q ;
  120.              q = p ;
  121.          }
  122.       }
  124.       if (_succ != NULL) continue;
  126.       w = _EntryList  ;
  127.       if (w != NULL) {
  128.           guarantee (w->TState == ObjectWaiter::TS_ENTER, "invariant") ;
  129.           ExitEpilog (Self, w) ;
  130.           return ;
  131.       }
  132.    }
  133. }

notify 唤醒

notify 或者 notifyAll 方法可以唤醒同一个锁监视器下调用 wait 挂起的线程，具体实现如下

  1. void ObjectMonitor::notify(TRAPS) {
  2.     CHECK_OWNER();
  3.     if (_WaitSet == NULL) {
  4.         TEVENT (Empty - Notify);
  5.         return;
  6.     }
  7.     DTRACE_MONITOR_PROBE(notify, this, object(), THREAD);
  9.     int Policy = Knob_MoveNotifyee;
  11.     Thread::SpinAcquire(&_WaitSetLock, "WaitSet - notify");
  12.     ObjectWaiter *iterator = DequeueWaiter();
  13.     if (iterator != NULL) {
  14.         // 省略一些代码
  16.          // 头插 EntryList
  17.         if (Policy == 0) {
  18.             if (List == NULL) {
  19.                 iterator->_next = iterator->_prev = NULL;
  20.                 _EntryList = iterator;
  21.             } else {
  22.                 List->_prev = iterator;
  23.                 iterator->_next = List;
  24.                 iterator->_prev = NULL;
  25.                 _EntryList = iterator;
  26.             }
  27.         } else if (Policy == 1) {      // 尾插 EntryList
  28.             if (List == NULL) {
  29.                 iterator->_next = iterator->_prev = NULL;
  30.                 _EntryList = iterator;
  31.             } else {
  32.                 ObjectWaiter *Tail;
  33.                 for (Tail = List; Tail->_next != NULL; Tail = Tail->_next);
  34.                 assert (Tail != NULL && Tail->_next == NULL, "invariant");
  35.                 Tail->_next = iterator;
  36.                 iterator->_prev = Tail;
  37.                 iterator->_next = NULL;
  38.             }
  39.         } else if (Policy == 2) {      // 头插 cxq
  40.             // prepend to cxq
  41.             if (List == NULL) {
  42.                 iterator->_next = iterator->_prev = NULL;
  43.                 _EntryList = iterator;
  44.             } else {
  45.                 iterator->TState = ObjectWaiter::TS_CXQ;
  46.                 for (;;) {
  47.                     ObjectWaiter *Front = _cxq;
  48.                     iterator->_next = Front;
  49.                     if (Atomic::cmpxchg_ptr(iterator, &_cxq, Front) == Front) {
  50.                         break;
  51.                     }
  52.                 }
  53.             }
  54.         } else if (Policy == 3) {      // 尾插 cxq
  55.             iterator->TState = ObjectWaiter::TS_CXQ;
  56.             for (;;) {
  57.                 ObjectWaiter *Tail;
  58.                 Tail = _cxq;
  59.                 if (Tail == NULL) {
  60.                     iterator->_next = NULL;
  61.                     if (Atomic::cmpxchg_ptr(iterator, &_cxq, NULL) == NULL) {
  62.                         break;
  63.                     }
  64.                 } else {
  65.                     while (Tail->_next != NULL) Tail = Tail->_next;
  66.                     Tail->_next = iterator;
  67.                     iterator->_prev = Tail;
  68.                     iterator->_next = NULL;
  69.                     break;
  70.                 }
  71.             }
  72.         } else {
  73.             ParkEvent *ev = iterator->_event;
  74.             iterator->TState = ObjectWaiter::TS_RUN;
  75.             OrderAccess::fence();
  76.             ev->unpark();
  77.         }
  79.         if (Policy < 4) {
  80.             iterator->wait_reenter_begin(this);
  81.         }
  82.     }
  83.     // 自旋释放
  84.     Thread::SpinRelease(&_WaitSetLock);
  86.     if (iterator != NULL && ObjectMonitor::_sync_Notifications != NULL) {
  87.         ObjectMonitor::_sync_Notifications->inc();
  88.     }
  89. }

三、Synchronized底层源码查看

3.1 Synchronized底层如何加锁的

3.1.1java对象在内存中的布局

Synchronized源码解读 - 图10
使用工具查看对象在内存中布局

  1.         <dependency>
  2.             <groupId>org.openjdk.jol</groupId>
  3.             <artifactId>jol-core</artifactId>
  4.             <version>0.9</version>
  5.         </dependency>
  1. ClassLayout.parseInstance(o).toPrintable()

Synchronized源码解读 - 图11
markword说明
Synchronized源码解读 - 图12

  1. 对象头Mark Word中的重量级锁指针指向的monitor对象，该对象是在HotSpot底层C++语言编写的(openjdk里面看)，简单看一下代码：
  1. //构造器
  2. ObjectMonitor() {
  3. _header = NULL;
  4. _count = 0;
  5. _waiters = 0，
  6. _recursions = 0; // 递归；线程的重入次数，典型的System.out.println
  7. _object = NULL; //  对应synchronized (object)对应里面的object
  8. _owner = NULL; // 标识拥有该monitor的线程
  9. _WaitSet = NULL; // 因为调用object.wait()方法而被阻塞的线程会被放在该队列中
  10. _WaitSetLock = 0 ;
  11. _Responsible = NULL;
  12. _succ = NULL;
  13. _cxq = NULL; // 竞争队列，所有请求锁的线程首先会被放在这个队列中
  14. FreeNext = NULL;
  15. _EntryList = NULL; // 阻塞；第二轮竞争锁仍然没有抢到的线程(偏向/可重入)
  16. _SpinFreq = 0;
  17. _SpinClock = 0;
  18. OwnerIsThread = 0;
  19. }

Synchronized源码解读 - 图13
klass pointer说明

  1. 这一部分用于存储对象的类型指针，该指针指向它的类元数据，jvm通过这个指针确定对象是哪个类的实例。该指针的位长度为JVM的一个字大小，即32位的JVM为32位，64位的JVM为64位。
  2. 如果应用的对象过多，使用64位的指针将浪费大量内存，统计而言，64的JVM将会比32位的JVM多耗费50的内存。为了节约内存可以使用选项 -XX:+UseCompressedOops 开启指针压缩。其中 oop即ordinary object pointer 普通对象指针。
  4. -XX:+UseCompressedOops 开启指针压缩
  5. -XX:-UseCompressedOops  不开启指针压缩
  6. 对象头：Mark Word+Klass Pointer类型指针 未开启压缩的情况下
  7. 32位 Mark Word =4bytes ，类型指针 4bytes ，对象头=8bytes =64bits
  8. 64位 Mark Word =8bytes ，类型指针 8bytes ，对象头=16bytes=128bits；
  9. 注意：默认情况下，开启了指针压缩 可能只有12字节。

实例属性说明

  1. 类中的成员属性

对齐填充

  1. 由于HotSpot虚拟机的自动内存管理系统要求对象的起始地址必须是8字节的整数倍，也就是对象的大小必须是8字节的整数倍。

3.1.2 方法加锁和代码块加锁的区别

  1. 1.代码块中加ynchronized 通过字节码可以看到，是通过在指令前后加monitor
  2. 2.方法中加ynchronized 通过字节码可以看到，是通过在方法上加ACC_SYNCHRONIZED标识

Synchronized源码解读 - 图14
Synchronized源码解读 - 图15

3.1.2 为什么monitorexit会有两次

  1. 为了保证出现异常,锁也能被释放掉

3.1.3 monitorexit一定会有两次？

  1. 当我们同步代码块中出现异常后，只会有一次，并且异常会抛给monitor，monitor释放完锁后会然后再把异常返回给我们

3.1.4 JVM对这两条指令的描述

  1. monitorenter ：
  3. Each object is associated with a monitor. A monitor is locked if and only if it has an owner. The thread that executes monitorenter attempts to gain ownership of the monitor associated with objectref, as follows: • If the entry count of the monitor associated with objectref is zero, the thread enters the monitor and sets its entry count to one. The thread is then the owner of the monitor. • If the thread already owns the monitor associated with objectref, it reenters the monitor, incrementing its entry count. • If another thread already owns the monitor associated with objectref, the thread blocks until the monitor's entry count is zero, then tries again to gain ownership
  5. 每个对象有一个监视器锁（monitor）。当monitor被占用时就会处于锁定状态，线程执行monitorenter指令时尝试获取monitor的所有权，过程如下：
  6.     如果monitor的进入数为0，则该线程进入monitor，然后将进入数设置为1，该线程即为monitor的所有者。
  7.     如果线程已经占有该monitor，只是重新进入，则进入monitor的进入数加1。
  8.     如果其他线程已经占用了monitor，则该线程进入阻塞状态，直到monitor的进入数为0，再重新尝试获取monitor的所有权。
  1. monitorexit：　
  3. The thread that executes monitorexit must be the owner of the monitor associated with the instance referenced by objectref. The thread decrements the entry count of the monitor associated with objectref. If as a result the value of the entry count is zero, the thread exits the monitor and is no longer its owner. Other threads that are blocking to enter the monitor are allowed to attempt to do so.
  6. 执行monitorexit的线程必须是objectref所对应的monitor的所有者。指令执行时，monitor的进入数减1，如果减1后进入数为0，那线程退出monitor，不再是这个monitor的所有者。其他被这个monitor阻塞的线程可以尝试去获取这个 monitor的所有权。 
  8. 通过这段话的描述，很清楚的看出Synchronized的实现原理，Synchronized底层通过一个monitor的对象来完成，wait/notify等方法其实也依赖于monitor对象，这就是为什么只有在同步的块或者方法中才能调用wait/notify等方法，否则会抛出java.lang.IllegalMonitorStateException的异常。
  10. 每个锁对象拥有一个锁计数器和一个指向持有该锁的线程的指针。
  12. 当执行monitorenter时，如果目标对象的计数器为零，那么说明它没有被其他线程所持有，Java虚拟机会将该锁对象的持有线程设置为当前线程，并且将其计数器加i。在目标锁对象的计数器不为零的情况下，如果锁对象的持有线程是当前线程，那么Java虚拟机可以将其计数器加1，否则需要等待，直至持有线程释放该锁。当执行monitorexit时，Java虚拟机则需将锁对象的计数器减1。计数器为零代表锁已被释放。

Synchronized源码解读 - 图16