【正本清源】Synchronized 源码全解之偏向锁的获取（基于 Openjdk12）

基于 hotspot 源码深度解析 Synchronized 偏向锁原理。欢迎友好交流，最好附带源码作为论据。

BasicObjectLock

包装了锁对象的头部和锁对象的引用。

class BasicObjectLock {
   
  friend class VMStructs;
 private:
  // 保存了被替换下来的对象的头部
  BasicLock _lock;                                    // the lock, must be double word aligned
  // oop java 对象的引用
  // typedef class oopDesc* oop;                            
  oop       _obj;                                     // object holds the lock;

 public:
  // Manipulation
  oop      obj() const                                {
    return _obj;  }
  void set_obj(oop obj)                               {
    _obj = obj; }
  BasicLock* lock()                                   {
    return &_lock; }

  static int size()                                   {
    return sizeof(BasicObjectLock)/wordSize; }

  void oops_do(OopClosure* f) {
    f->do_oop(&_obj); }

  static int obj_offset_in_bytes()                    {
    return offset_of(BasicObjectLock, _obj);  }
  static int lock_offset_in_bytes()                   {
    return offset_of(BasicObjectLock, _lock); }
};

BasicLock

class BasicLock {
   
  friend class VMStructs;
  friend class JVMCIVMStructs;
 private:
  volatile markOop _displaced_header; // 被替换下来的对象头部
 public:
  markOop      displaced_header() const               {
    return _displaced_header; }
  void         set_displaced_header(markOop header)   {
    _displaced_header = header; }

  void print_on(outputStream* st) const;

  void move_to(oop obj, BasicLock* dest);

  static int displaced_header_offset_in_bytes()       {
    return offset_of(BasicLock, _displaced_header); }
};

oopDesc

hotspot/src/share/vm/oops/oop.hpp
所有对象头部的基类

typedef class markOopDesc* markOop; // oopsHierarchy.hpp

class oopDesc {
   
  friend class VMStructs;
 private