Java 并发底层源码分析

JVM_ENTRY(void, JVM_StartThread(JNIEnv* env, jobject jthread))
  JVMWrapper("JVM_StartThread");
  JavaThread *native_thread = NULL;
  // We cannot hold the Threads_lock when we throw an exception,
  // due to rank ordering issues. Example:  we might need to grab the
  // Heap_lock while we construct the exception.
  bool throw_illegal_thread_state = false;
  // We must release the Threads_lock before we can post a jvmti event
  // in Thread::start.
  {
    // Ensure that the C++ Thread and OSThread structures aren't freed before
    // we operate.
    MutexLocker mu(Threads_lock);
    // Since JDK 5 the java.lang.Thread threadStatus is used to prevent
    // re-starting an already started thread, so we should usually find
    // that the JavaThread is null. However for a JNI attached thread
    // there is a small window between the Thread object being created
    // (with its JavaThread set) and the update to its threadStatus, so we
    // have to check for this
    if (java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread)) != NULL) {
      throw_illegal_thread_state = true;
    } else {
      // We could also check the stillborn flag to see if this thread was already stopped, but
      // for historical reasons we let the thread detect that itself when it starts running
      jlong size =
             java_lang_Thread::stackSize(JNIHandles::resolve_non_null(jthread));
      // Allocate the C++ Thread structure and create the native thread.  The
      // stack size retrieved from java is 64-bit signed, but the constructor takes
      // size_t (an unsigned type), which may be 32 or 64-bit depending on the platform.
      //  - Avoid truncating on 32-bit platforms if size is greater than UINT_MAX.
      //  - Avoid passing negative values which would result in really large stacks.
      NOT_LP64(if (size > SIZE_MAX) size = SIZE_MAX;)
      size_t sz = size > 0 ? (size_t) size : 0;
      // 重点看这里！！！
      native_thread = new JavaThread(&thread_entry, sz);
      // At this point it may be possible that no osthread was created for the
      // JavaThread due to lack of memory. Check for this situation and throw
      // an exception if necessary. Eventually we may want to change this so
      // that we only grab the lock if the thread was created successfully -
      // then we can also do this check and throw the exception in the
      // JavaThread constructor.
      if (native_thread->osthread() != NULL) {
        // Note: the current thread is not being used within "prepare".
        native_thread->prepare(jthread);
      }
    }
  }
  if (throw_illegal_thread_state) {
    THROW(vmSymbols::java_lang_IllegalThreadStateException());
  }
  assert(native_thread != NULL, "Starting null thread?");
  if (native_thread->osthread() == NULL) {
    // No one should hold a reference to the 'native_thread'.
    native_thread->smr_delete();
    if (JvmtiExport::should_post_resource_exhausted()) {
      JvmtiExport::post_resource_exhausted(
        JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR | JVMTI_RESOURCE_EXHAUSTED_THREADS,
        os::native_thread_creation_failed_msg());
    }
    THROW_MSG(vmSymbols::java_lang_OutOfMemoryError(),
              os::native_thread_creation_failed_msg());
  }
  Thread::start(native_thread);
JVM_END

native_thread = new JavaThread(&thread_entry, sz);

JavaThread::JavaThread(ThreadFunction entry_point, size_t stack_sz) :
                       Thread() {
  initialize();
  _jni_attach_state = _not_attaching_via_jni;
  set_entry_point(entry_point);
  // Create the native thread itself.
  // %note runtime_23
  os::ThreadType thr_type = os::java_thread;
  thr_type = entry_point == &compiler_thread_entry ? os::compiler_thread :
                                                     os::java_thread;
  // 通过 os 类的 create_thread 函数来创建一个线程
  os::create_thread(this, thr_type, stack_sz);
  // The _osthread may be NULL here because we ran out of memory (too many threads active).
  // We need to throw and OutOfMemoryError - however we cannot do this here because the caller
  // may hold a lock and all locks must be unlocked before throwing the exception (throwing
  // the exception consists of creating the exception object & initializing it, initialization
  // will leave the VM via a JavaCall and then all locks must be unlocked).
  //
  // The thread is still suspended when we reach here. Thread must be explicit started
  // by creator! Furthermore, the thread must also explicitly be added to the Threads list
  // by calling Threads:add. The reason why this is not done here, is because the thread
  // object must be fully initialized (take a look at JVM_Start)
}

bool os::create_thread(Thread* thread, ThreadType thr_type,
                       size_t req_stack_size) {
  ...
  // init thread attributes
  pthread_attr_t attr;
  pthread_attr_init(&attr);
  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
  // Calculate stack size if it's not specified by caller.
  size_t stack_size = os::Posix::get_initial_stack_size(thr_type, req_stack_size);
  // In the Linux NPTL pthread implementation the guard size mechanism
  // is not implemented properly. The posix standard requires adding
  // the size of the guard pages to the stack size, instead Linux
  // takes the space out of 'stacksize'. Thus we adapt the requested
  // stack_size by the size of the guard pages to mimick proper
  // behaviour. However, be careful not to end up with a size
  // of zero due to overflow. Don't add the guard page in that case.
  size_t guard_size = os::Linux::default_guard_size(thr_type);
  if (stack_size <= SIZE_MAX - guard_size) {
    stack_size += guard_size;
  }
  assert(is_aligned(stack_size, os::vm_page_size()), "stack_size not aligned");
  int status = pthread_attr_setstacksize(&attr, stack_size);
  assert_status(status == 0, status, "pthread_attr_setstacksize");
  // Configure glibc guard page.
  pthread_attr_setguardsize(&attr, os::Linux::default_guard_size(thr_type));
  ...
  pthread_t tid;
  // 创建并启动线程
  int ret = pthread_create(&tid, &attr, (void* (*)(void*)) thread_native_entry, thread);
  ...
}

pthread_t tid;
// 创建并启动线程
int ret = pthread_create(&tid, &attr, (void* (*)(void*)) thread_native_entry, thread);

int
pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg);

// Thread start routine for all newly created threads
static void *thread_native_entry(Thread *thread) {
  ...
  // call one more level start routine
  thread->run();
  ...
}

os::create_thread(this, thr_type, stack_sz);

// The first routine called by a new Java thread
void JavaThread::run() {
  ...
  // We call another function to do the rest so we are sure that the stack addresses used
  // from there will be lower than the stack base just computed
  thread_main_inner();
}

void JavaThread::thread_main_inner() {
  assert(JavaThread::current() == this, "sanity check");
  assert(this->threadObj() != NULL, "just checking");
  // Execute thread entry point unless this thread has a pending exception
  // or has been stopped before starting.
  // Note: Due to JVM_StopThread we can have pending exceptions already!
  if (!this->has_pending_exception() &&
      !java_lang_Thread::is_stillborn(this->threadObj())) {
    {
      ResourceMark rm(this);
      this->set_native_thread_name(this->get_thread_name());
    }
    HandleMark hm(this);
    // 这里开始调用 java thread 的 run 方法啦～～～
    this->entry_point()(this, this);
  }
  DTRACE_THREAD_PROBE(stop, this);
  // java 中的 run 方法执行完毕了，这里需要退出线程并清理资源
  this->exit(false);
  // delete cpp 的对象
  this->smr_delete();
}

ThreadFunction entry_point() const             { return _entry_point; }

typedef void (*ThreadFunction)(JavaThread*, TRAPS);

native_thread = new JavaThread(&thread_entry, sz);

JavaThread::JavaThread(ThreadFunction entry_point, size_t stack_sz) :
                       Thread() {
   ...
   set_entry_point(entry_point);
   ...
}

static void thread_entry(JavaThread* thread, TRAPS) {
  HandleMark hm(THREAD);
  Handle obj(THREAD, thread->threadObj());
  JavaValue result(T_VOID);
  JavaCalls::call_virtual(&result,
                          obj,
                          SystemDictionary::Thread_klass(),
                          vmSymbols::run_method_name(),
                          vmSymbols::void_method_signature(),
                          THREAD);
}

  #define VM_SYMBOL_DECLARE(name, ignore)                 \
    static Symbol* name() {                               \
      return _symbols[VM_SYMBOL_ENUM_NAME(name)];         \
    }
  VM_SYMBOLS_DO(VM_SYMBOL_DECLARE, VM_SYMBOL_DECLARE)
  #undef VM_SYMBOL_DECLARE

template(run_method_name,                           "run")  \

template(void_method_signature,                     "()V")  \

java_lang_Thread->JNI:start0
JNI->JavaThread:new
JavaThread->os:create_thread
os->os_linux:pthread_create
os_linux->JavaThread:thread_entry
JavaThread->java_lang_Thread:run

def(Bytecodes::_monitorenter        , ____|disp|clvm|____, atos, vtos, monitorenter        ,  _           );
def(Bytecodes::_monitorexit         , ____|____|clvm|____, atos, vtos, monitorexit         ,  _           );

// Stack layout:
//
// [expressions  ] <--- rsp               = expression stack top
// ..
// [expressions  ]
// [monitor entry] <--- monitor block top = expression stack bot
// ..
// [monitor entry]
// [frame data   ] <--- monitor block bot
// ...
// [saved rbp    ] <--- rbp
void TemplateTable::monitorenter() {
  // 被锁对象(lockee)不能为空
  __ null_check(rax);
  ...
  // 从底至顶遍历线程栈(栈结构如上面注释),寻找一个空闲的Lock Record，并保存至c_rarg1
  {
    Label entry, loop, exit;  //声明三个Label
    __ movptr(c_rarg3, monitor_block_top); //声明栈顶指针
    __ lea(c_rarg2, monitor_block_bot); //声明栈底指针
    ...
    __ bind(loop);//  绑定循环头，用于下面跳转回来
    // 检查这个Lock Record是否已使用
    __ cmpptr(Address(c_rarg3, BasicObjectLock::obj_offset_in_bytes()), (int32_t) NULL_WORD);
    // 若未使用就记录至c_rarg1
    __ cmov(Assembler::equal, c_rarg1, c_rarg3);
    // 检查Lock Record的_obj属性是否就是被锁对象(lockee)
    __ cmpptr(rax, Address(c_rarg3, BasicObjectLock::obj_offset_in_bytes()));
    // 是的话代表这是锁重入，就跳转到exit标签，停止搜索
    __ jccb(Assembler::equal, exit);
    // 否则指针移向向下一个Lock Record
    __ addptr(c_rarg3, entry_size);
    __ bind(entry);
    // 检查是否到栈顶了
    __ cmpptr(c_rarg3, c_rarg2);
    __ jcc(Assembler::notEqual, loop);//没到底就跳转回loop标签，继续循环
    /*结束*/
    __ bind(exit);
  }
  
  __ testptr(c_rarg1, c_rarg1); // 检查是否找到了空闲的Lock Record
  __ jcc(Assembler::notZero, allocated); // 如果找到，跳转到allocated中继续

  // 若没有找到，就扩容并分配一个：
  {
    Label entry, loop;
    // 1. 计算新的指针（扩容                // rsp: old expression stack top
    __ movptr(c_rarg1, monitor_block_bot); // c_rarg1: old expression stack bottom
    __ subptr(rsp, entry_size);            // move expression stack top
    __ subptr(c_rarg1, entry_size);        // move expression stack bottom
    __ mov(c_rarg3, rsp);                  // set start value for copy loop
    __ movptr(monitor_block_bot, c_rarg1); // set new monitor block bottom
    __ jmp(entry);
    // 2. 移动操作栈(expression stack)内容到新位置
    __ bind(loop);
    __ movptr(c_rarg2, Address(c_rarg3, entry_size)); // load expression stack
                                                      // word from old location
    __ movptr(Address(c_rarg3, 0), c_rarg2);          // and store it at new location
    __ addptr(c_rarg3, wordSize);                     // advance to next word
    __ bind(entry);
    __ cmpptr(c_rarg3, c_rarg1);            // check if bottom reached
    __ jcc(Assembler::notEqual, loop);      // if not at bottom then
                                            // copy next word
  }

  // 执行到这说明已经找到空闲Lock Record，保存在c_rarg1中
  __ bind(allocated);
  ...
  // 将被锁对象(lockee)存放至空闲Lock Record中
  __ movptr(Address(c_rarg1, BasicObjectLock::obj_offset_in_bytes()), rax);
  // 跳转执行 lock_object 函数
  __ lock_object(c_rarg1);
  ...
}

// A BasicObjectLock associates a specific Java object with a BasicLock.
// It is currently embedded in an interpreter frame.
...
class BasicObjectLock VALUE_OBJ_CLASS_SPEC {
  friend class VMStructs;
 private:
  BasicLock _lock;                                    // the lock, must be double word aligned
  oop       _obj;                                     // object holds the lock;

  ...
}

class BasicLock VALUE_OBJ_CLASS_SPEC {
  friend class VMStructs;
 private:
  volatile markOop _displaced_header;

  ...
}

void InterpreterMacroAssembler::lock_object(Register lock_reg) {
  ......
  // 如果使用重量级锁，直接进入InterpreterRuntime::monitorenter()执行
  if (UseHeavyMonitors) {
    call_VM(noreg,
            CAST_FROM_FN_PTR(address, InterpreterRuntime::monitorenter),
            lock_reg);
  } else {
    ......
    if (UseBiasedLocking) {
      biased_locking_enter(lock_reg, obj_reg, swap_reg, tmp_reg, false, done, &slow_case);
    }
    ......
    // Call the runtime routine for slow case
    call_VM(noreg,
            CAST_FROM_FN_PTR(address, InterpreterRuntime::monitorenter),
            lock_reg);
    ......
    // 直接跳到这表明获取锁成功，接下来就会返回到同步代码块里进行字节码的执行了。
  }
}

  volatile markOop _mark;
  union _metadata {
    Klass*      _klass;
    narrowKlass _compressed_klass;
  } _metadata;

//  32 bits:
//  --------
//             hash:25 ------------>| age:4    biased_lock:1 lock:2 (normal object)
//             JavaThread*:23 epoch:2 age:4    biased_lock:1 lock:2 (biased object)
//             size:32 ------------------------------------------>| (CMS free block)
//             PromotedObject*:29 ---------->| promo_bits:3 ----->| (CMS promoted object)
//
//  64 bits:
//  --------
//  unused:25 hash:31 -->| unused:1   age:4    biased_lock:1 lock:2 (normal object)
//  JavaThread*:54 epoch:2 unused:1   age:4    biased_lock:1 lock:2 (biased object)
//  PromotedObject*:61 --------------------->| promo_bits:3 ----->| (CMS promoted object)
//  size:64 ----------------------------------------------------->| (CMS free block)
//
//  unused:25 hash:31 -->| cms_free:1 age:4    biased_lock:1 lock:2 (COOPs && normal object)
//  JavaThread*:54 epoch:2 cms_free:1 age:4    biased_lock:1 lock:2 (COOPs && biased object)
//  narrowOop:32 unused:24 cms_free:1 unused:4 promo_bits:3 ----->| (COOPs && CMS promoted object)
//  unused:21 size:35 -->| cms_free:1 unused:7 ------------------>| (COOPs && CMS free block)
...
//    [JavaThread* | epoch | age | 1 | 01]       lock is biased toward given thread
//    [0           | epoch | age | 1 | 01]       lock is anonymously biased
//
//  - the two lock bits are used to describe three states: locked/unlocked and monitor.
//
//    [ptr             | 00]  locked             ptr points to real header on stack
//    [header      | 0 | 01]  unlocked           regular object header
//    [ptr             | 10]  monitor            inflated lock (header is wapped out)
//    [ptr             | 11]  marked             used by markSweep to mark an object
//                                               not valid at any other time

|------------------------------------------------------------------------------|--------------------|
|                                  Mark Word (64 bits)                         |       State        |
|------------------------------------------------------------------------------|--------------------|
| unused:25 | identity_hashcode:31 | unused:1 | age:4 | biased_lock:0 | lock:01|     正常(无锁)      |
|------------------------------------------------------------------------------|--------------------|
| thread:54(全0) |     epoch:2     | unused:1 | age:4 | biased_lock:1 | lock:01|       匿名偏向      |
|------------------------------------------------------------------------------|--------------------|
| thread:54      |     epoch:2     | unused:1 | age:4 | biased_lock:1 | lock:01|       偏向锁       |
|------------------------------------------------------------------------------|--------------------|
|                       ptr_to_lock_record:62                         | lock:00|       轻量级锁     |
|------------------------------------------------------------------------------|--------------------|
|                     ptr_to_heavyweight_monitor:62                   | lock:10|       重量级锁     |
|------------------------------------------------------------------------------|--------------------|
|                                                                     | lock:11|       GC标记       |
|------------------------------------------------------------------------------|--------------------|

void InterpreterMacroAssembler::lock_object(Register lock_reg) {
  ......
  // 如果使用重量级锁，直接进入InterpreterRuntime::monitorenter()执行
  if (UseHeavyMonitors) {
    call_VM(noreg,
            CAST_FROM_FN_PTR(address, InterpreterRuntime::monitorenter),
            lock_reg);
  } else {
    Label done;
    // cmpxchg其实就是CAS操作，必须使用rax寄存器作为老数据的存储。
    const Register swap_reg = rax; // Must use rax for cmpxchg instruction
    const Register tmp_reg = rbx; // Will be passed to biased_locking_enter to avoid a problematic case where tmp_reg = no_reg.
    const Register obj_reg = LP64_ONLY(c_rarg3) NOT_LP64(rcx); // Will contain the oop

    ......
    Label slow_case;

    // Load object pointer into obj_reg
    movptr(obj_reg, Address(lock_reg, obj_offset));
    //如果虚拟机参数允许使用偏向锁，那么进入biased_locking_enter()中
    if (UseBiasedLocking) {
      // lock_reg :存储的是分配的BasicObjectLock的指针
      // obj_reg :存储的是锁对象的指针
      // slow_case :即InterpreterRuntime::monitorenter()；
      // done :标志着获取锁成功。

      // slow_case 和 done 也被传入，这样在biased_locking_enter()中，就可以根据情况跳到这两处了。
      biased_locking_enter(lock_reg, obj_reg, swap_reg, tmp_reg, false, done, &slow_case);
    }

    // Load immediate 1 into swap_reg %rax,
    movptr(swap_reg, (int32_t)1);
    // Load (object->mark() | 1) into swap_reg %rax,
    orptr(swap_reg, Address(obj_reg, 0));
    // Save (object->mark() | 1) into BasicLock's displaced header
    movptr(Address(lock_reg, mark_offset), swap_reg);
    ...
    cmpxchgptr(lock_reg, Address(obj_reg, 0));
    jcc(Assembler::zero, done);

    // Test if the oopMark is an obvious stack pointer, i.e.,
    //  1) (mark & 3) == 0, and
    //  2) rsp <= mark < mark + os::pagesize()
    //
    // These 3 tests can be done by evaluating the following
    // expression: ((mark - rsp) & (3 - os::vm_page_size())),
    // assuming both stack pointer and pagesize have their
    // least significant 2 bits clear.
    // NOTE: the oopMark is in swap_reg %rax, as the result of cmpxchg
    subptr(swap_reg, rsp);
    andptr(swap_reg, 3 - os::vm_page_size());

    // Save the test result, for recursive case, the result is zero
    movptr(Address(lock_reg, mark_offset), swap_reg);

    jcc(Assembler::zero, done);

    // 如果使用重量级锁，直接跳到这，需要进入InterpreterRuntime::monitorenter()中去获取锁。
    bind(slow_case);
    // Call the runtime routine for slow case
    call_VM(noreg,
            CAST_FROM_FN_PTR(address, InterpreterRuntime::monitorenter),
            lock_reg);
    // 直接跳到这表明获取锁成功，接下来就会返回进行同步块内字节码的执行了。
    bind(done);
  }
}

// mark_addr:锁对象头中的markOop指针。
Address mark_addr      (obj_reg, oopDesc::mark_offset_in_bytes());
NOT_LP64( Address saved_mark_addr(lock_reg, 0); )

if (PrintBiasedLockingStatistics && counters == NULL) {
  counters = BiasedLocking::counters();
}

Label cas_label;
int null_check_offset = -1;
// 如果swap_reg中没存mark_addr，那么就先将mark_addr存入swap_reg中。
if (!swap_reg_contains_mark) {
  null_check_offset = offset();
  movptr(swap_reg, mark_addr);
}
// 将对象的mark_addr，即markOop指针移入tmp_reg中
movptr(tmp_reg, swap_reg);
// 将tmp_reg和biased_lock_mask_in_place进行与操作，
// biased_lock_mask_in_place为111，和它进行与就可以取出markOop中后三位，
// 即(是否偏向锁+锁标志位)
andptr(tmp_reg, markOopDesc::biased_lock_mask_in_place);
// 将上面结果，即(是否偏向锁+锁标志位)和biased_lock_pattern再次比较(biased_lock_pattern为5，即101)，
// 如果不相等，则表明不为可偏向状态，需要进行CAS操作，跳往cas_label(在该函数最后return处)，
// 交回lock_object中处理；否则即为可偏向状态，接着往下走。
cmpptr(tmp_reg, markOopDesc::biased_lock_pattern);
jcc(Assembler::notEqual, cas_label);

// 将锁对象所属类的prototype_header移动至tmp_reg中，prototype_header中存储的也是markOop。
// prototype_header是专门为偏向锁打造的，初始时类的prototype_header为偏向锁态，即后三位为101，一旦发生了bulk_revoke,那么就会设为无锁态，即001。
// bulk_revoke为批量撤销，每次类发生bulk_rebais时（类的所有对象重设偏向锁），
// 类prototype_header中的epoch就会+1，当epoch达到一个阈值时，
// 就会发生bulk_revoke，撤销该类每个对象的偏向锁，这样该类的所有对象以后都不能使用偏向锁了，
// 其实也就是虚拟机认为该对象不适合偏向锁。
load_prototype_header(tmp_reg, obj_reg);

// 构造一个新的markOop:
// 将当前线程id和类的prototype_header相或，
// 这样得到的markOop为(当前线程id + prototype_header中的(epoch + 分代年龄 + 偏向锁标志 + 锁标志位))，
// 注意prototype_header的分代年龄那4个字节为0
orptr(tmp_reg, r15_thread);
// 将上面构造的新markOop与锁对象的markOop进行异或，tmp_reg中相等的位全部被置为0，只剩下不相等的位。
xorptr(tmp_reg, swap_reg);
Register header_reg = tmp_reg;
// 对((int) markOopDesc::age_mask_in_place)进行按位取反，age_mask_in_place为...0001111000,
// 取反后，变成了...1110000111,除了分代年龄那4位，其他位全为1；
// 将取反后的结果再与header_reg相与，这样就把header_reg中除了分代年龄之外的其他位取了出来，
// 即将上面异或得到的结果中分代年龄给忽略掉。
andptr(header_reg, ~((int) markOopDesc::age_mask_in_place));
// 如果除了分代年龄，对象的markOop和（当前线程id+其他位）相等，那么上面与操作的结果应该为0，
// 表明对象之前已经偏向当前线程，即markOop中存放有当前线程id，那么跳到done处，直接进入同步代码块执行即可；
// 否则表明当前线程还不是偏向锁的持有者，会接着往下走。
jcc(Assembler::equal, done);

// test指令使header_reg(前面的异或结果)和biased_lock_mask_in_place(即二进制111)进行与运算
testptr(header_reg, markOopDesc::biased_lock_mask_in_place);
// 如果不为0表示 类prototype_header和对象markOop后三位不相等，
// 而能走到这，表明对象markword后三位为101，即偏向模式，
// 因此，test指令结果不为0表明了对象所属类不再支持偏向，发生了bulk_revoke，
// 所以需要对当前对象进行偏向锁的撤销；
// 否则表明目前该类还支持偏向锁，接着往下走。
jccb(Assembler::notZero, try_revoke_bias);

// 测试对象所属类的prototype_header中epoch是否为0，不为0的话则表明之前异或时，
// 类的prototype_header中epoch和对象markOop的epoch不相等，
// 表明类在对象分配后发生过bulk_rebais()（前面提到过，每次发生bulk_rebaise,
// 类的prototype header中的epoch都会+1），
// 所以之前对象的偏向就无效了，需要进行重偏向，转跳到try_rebias标签。否则接着往下走。
testptr(header_reg, markOopDesc::epoch_mask_in_place);
jccb(Assembler::notZero, try_rebias);

// 取出对象markOop中除线程id之外的其他位，即代表匿名偏向状态的markOop，放入swap_reg
andptr(swap_reg,
        markOopDesc::biased_lock_mask_in_place | markOopDesc::age_mask_in_place | markOopDesc::epoch_mask_in_place);
// 将匿名偏向状态的markOop移动至 tmp_reg，准备构建新的markOop
movptr(tmp_reg, swap_reg);
// 将其他位和当前线程id进行或，构造成一个新的完整的一个字(32bit/64bit)的markOop,存入tmp_reg中。
// 新的markOop因为保存了当前线程id，表示偏向当前线程。
orptr(tmp_reg, r15_thread);
// 尝试利用CAS操作将新构成的markOop存入对象头的mark_addr处，如果设置成功，则获取偏向锁成功。
// 这里说明下，cmpxchgptr操作会强制将rax寄存器（swap_reg）中内容作为老数据，与第二个参数，
// 在这里即mark_addr处的内容进行比较，如果相等(代表原本的markOop就是匿名偏向对象)，
// 则将第一个参数的内容，即tmp_reg中的新数据，存入mark_addr。
cmpxchgptr(tmp_reg, mark_addr); // compare tmp_reg and swap_reg
// 上面CAS操作若成功，就完成了偏向锁的获取；
// 上面CAS操作若干失败，表明对象头中的markOop数据已经被篡改，即该锁对象已经偏向其他线程，
// 因为偏向锁不容许多个线程访问同一个锁对象，所以需要跳到slow_case处，去撤销该对象的偏向锁，并进行锁升级。
if (slow_case != NULL) {
  //  若成功ZF标志(Zero Flag)被设置，notZero不成立，不跳转，继续执行；
  //  反之，跳转到slow_case处
  jcc(Assembler::notZero, *slow_case);
}
// 上面CAS成功的情况下，直接就跳往done处，回去执行方法的字节码了。
jmp(done);

bind(try_rebias);
// 构建一个偏向当前线程的markOop
// 先将锁对象所属类的prototype_header送入tmp_reg。
load_prototype_header(tmp_reg, obj_reg);
// 设置当前线程ID到tmp_reg里，此时markOop为偏向当前线程的markOop
orptr(tmp_reg, r15_thread);
// 尝试用CAS操作，将新建的markOop设置到对象的mark word中
cmpxchgptr(tmp_reg, mark_addr);
// 和第5步一样，如果CAS失败，则表明对象头的markOop数据已经被其他线程更改，
// 需要跳往slow_case进行撤销偏向锁，否则跳往done处，执行字节码。
if (slow_case != NULL) {
  jcc(Assembler::notZero, *slow_case);
}
jmp(done);

bind(try_revoke_bias);
// 走到这，表明这个类的prototype_header中已经没有可偏向的位了，
// 即这个类的所有对象都不再支持偏向锁了，但是当前对象仍为可偏向状态，
// 所以我们需要重置下当前对象的markOop为无锁态。
// 将锁对象所属类的prototype_header(无锁态)送入tmp_reg。
load_prototype_header(tmp_reg, obj_reg);
// 尝试用CAS操作，使对象的markOop重置为无锁态。
// 这里是否失败无所谓，即使失败了，也表明其他线程已经移除了对象的偏向锁标志。
cmpxchgptr(tmp_reg, mark_addr);
//接下来会回到lock_object()方法中，继续轻量级锁的获取。
bind(cas_label);
return null_check_offset;

void TemplateTable::monitorexit() {
  ...
  // 要解锁的被锁对象(lockee)不能为空
  __ null_check(rax);
  ...
  // 从底至顶遍历线程栈,寻找关联要解锁的被锁对象(lockee)的Lock Record，存放到c_rarg1
  {
    ...
    __ movptr(c_rarg1, monitor_block_top); //声明栈顶指针
    __ lea(c_rarg2, monitor_block_bot); //声明栈底指针
    ...
    __ bind(loop);//  绑定循环头，用于下面跳转回来
    // 检查这个Lock Record关联的是否是要解锁的被锁对象(lockee)
    __ cmpptr(rax, Address(c_rarg1, BasicObjectLock::obj_offset_in_bytes()));
    // 如果是的话停止搜索，跳转到found标签
    __ jcc(Assembler::equal, found);
    // 否则指针移向向下一个Lock Record
    __ addptr(c_rarg1, entry_size);
    ...
    // 检查是否到栈顶了
    __ cmpptr(c_rarg1, c_rarg2);
    //没到底就跳转回loop标签，继续循环
    __ jcc(Assembler::notEqual, loop);
  }

  // 若没找到就抛异常
  // error handling. Unlocking was not block-structured
  __ call_VM(noreg, CAST_FROM_FN_PTR(address,
                   InterpreterRuntime::throw_illegal_monitor_state_exception));
  __ should_not_reach_here();
  ...
  __ bind(found);
  __ push_ptr(rax); // make sure object is on stack (contract with oopMaps)
  // 跳转执行 unlock_object 函数，此时c_rarg1存放的是该锁对象的Lock Record
  __ unlock_object(c_rarg1);
  __ pop_ptr(rax); // discard object
}

void InterpreterMacroAssembler::unlock_object(Register lock_reg) {
  ...
  // Convert from BasicObjectLock structure to object and BasicLock structure
  // 保存BasicObjectLock中的BasicLock地址到swap_reg，
  // 下面的cmpxchg指令会对比第二个参数是否与此相同，当相同CAS才成功
  lea(swap_reg, Address(lock_reg, BasicObjectLock::lock_offset_in_bytes()));

  // 将oop(锁关联对象)存入obj_reg
  movptr(obj_reg, Address(lock_reg, BasicObjectLock::obj_offset_in_bytes ()));

  // 将BasicObjectLock的关联对象oop设置为NULL,即释放Lock Record
  movptr(Address(lock_reg, BasicObjectLock::obj_offset_in_bytes()), NULL_WORD);

  //如果开启了偏向锁
  if (UseBiasedLocking) {
    // 对于偏向锁，会直接跳转到done；
    // 对轻量级锁，会继续执行下面的代码
    biased_locking_exit(obj_reg, header_reg, done);
  }
  ...
  // 如果是递归的情况
  testptr(header_reg, header_reg);
  // 就直接转跳到done，结束执行
  jcc(Assembler::zero, done);
  ...
  // 要将Displaced Mark Word通过CAS设置到对象头的Mark Word
  if (os::is_MP()) lock();
  cmpxchgptr(header_reg, Address(obj_reg, 0));

  // 如果CAS成功了，跳转到done；否则执行InterpreterRuntime::monitorexit
  jcc(Assembler::zero, done);

  // Call the runtime routine for slow case.
  movptr(Address(lock_reg, BasicObjectLock::obj_offset_in_bytes()), obj_reg); // restore obj
  call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::monitorexit), lock_reg);

  bind(done);
}

void MacroAssembler::biased_locking_exit(Register obj_reg, Register temp_reg, Label& done) {
  assert(UseBiasedLocking, "why call this otherwise?");

  // Check for biased locking unlock case, which is a no-op
  // Note: we do not have to check the thread ID for two reasons.
  // First, the interpreter checks for IllegalMonitorStateException at
  // a higher level. Second, if the bias was revoked while we held the
  // lock, the object could not be rebiased toward another thread, so
  // the bias bit would be clear.
  movptr(temp_reg, Address(obj_reg, oopDesc::mark_offset_in_bytes()));
  andptr(temp_reg, markOopDesc::biased_lock_mask_in_place);
  cmpptr(temp_reg, markOopDesc::biased_lock_pattern);
  jcc(Assembler::equal, done);
}

// Synchronization
//
// The interpreter's synchronization code is factored out so that it can
// be shared by method invocation and synchronized blocks.
//%note synchronization_3
//%note monitor_1
IRT_ENTRY_NO_ASYNC(void, InterpreterRuntime::monitorenter(JavaThread* thread, BasicObjectLock* elem))
  Handle h_obj(thread, elem->obj());
  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);
  }
IRT_END

//  Fast Monitor Enter/Exit
// This the fast monitor enter. The interpreter and compiler use
// some assembly copies of this code. Make sure update those code
// if the following function is changed. The implementation is
// extremely sensitive to race condition. Be careful.
void ObjectSynchronizer::fast_enter(Handle obj, BasicLock* lock,
                                    bool attempt_rebias, TRAPS) {
  //虚拟机参数判断是否开启了偏向锁
  if (UseBiasedLocking) {
    //如果不处于全局安全点，即正常的Java线程
    if (!SafepointSynchronize::is_at_safepoint()) {
      //通过`revoke_and_rebias`这个函数尝试撤销或重偏向偏向锁
      BiasedLocking::Condition cond = BiasedLocking::revoke_and_rebias(obj, attempt_rebias, THREAD);
      if (cond == BiasedLocking::BIAS_REVOKED_AND_REBIASED) {
        return;
      }
    } else {//如果在安全点，即VM线程，撤销偏向锁
      assert(!attempt_rebias, "can not rebias toward VM thread");
      BiasedLocking::revoke_at_safepoint(obj);
    }
    assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
  }
  slow_enter(obj, lock, THREAD);
}

BiasedLocking::Condition BiasedLocking::revoke_and_rebias(Handle obj, bool attempt_rebias, TRAPS) {
  //1：必须在安全点
  assert(!SafepointSynchronize::is_at_safepoint(), "must not be called while at safepoint");
  //2：读取对象头
  markOop mark = obj->mark();
  //is_biased_anonymously()判断mark是否为可偏向状态，即mark的偏向锁标志位为1，锁标志位为 01，线程id为null
  //当计算hashCode时，进入此分支，会在一个非全局安全点进行偏向锁撤销(BIAS_REVOKED)
  if (mark->is_biased_anonymously() && !attempt_rebias) {
    markOop biased_value       = mark;
    //创建一个非偏向的markword
    markOop unbiased_prototype = markOopDesc::prototype()->set_age(mark->age());
    //通过cas重新设置偏向锁状态
    markOop res_mark = (markOop) Atomic::cmpxchg_ptr(unbiased_prototype, obj->mark_addr(), mark);
    //如果CAS成功，返回偏向锁撤销状态
    if (res_mark == biased_value) {
      return BIAS_REVOKED;
    }
  } else if (mark->has_bias_pattern()) {
    //如果锁对象为可偏向状态（biased_lock:1, lock:01，不管线程id是否为空）,尝试重新偏向
    Klass* k = obj->klass();
    markOop prototype_header = k->prototype_header();
    //如果对应class关闭了偏向模式，则取消偏向锁操作
    if (!prototype_header->has_bias_pattern()) {
      // This object has a stale bias from before the bulk revocation
      // for this data type occurred. It's pointless to update the
      // heuristics at this point so simply update the header with a
      // CAS. If we fail this race, the object's bias has been revoked
      // by another thread so we simply return and let the caller deal
      // with it.
      markOop biased_value       = mark;
      //CAS 更新对象头markword为非偏向锁
      markOop res_mark = (markOop) Atomic::cmpxchg_ptr(prototype_header, obj->mark_addr(), mark);
      assert(!(*(obj->mark_addr()))->has_bias_pattern(), "even if we raced, should still be revoked");
      return BIAS_REVOKED;
    } else if (prototype_header->bias_epoch() != mark->bias_epoch()) {//如果偏向锁epoch过期，则进入当前分支
      //如果允许尝试重新偏向
      if (attempt_rebias) {
        assert(THREAD->is_Java_thread(), "");
        markOop biased_value       = mark;
        //构建新的偏向本线程的markOop，设置好本线程的 ThreadID 、分代年龄、epoch值
        markOop rebiased_prototype = markOopDesc::encode((JavaThread*) THREAD, mark->age(), prototype_header->bias_epoch());
        //通过CAS 操作， 将尝试新markOop写入对象头中
        markOop res_mark = (markOop) Atomic::cmpxchg_ptr(rebiased_prototype, obj->mark_addr(), mark);
        //CAS成功，则返回撤销和重新偏向状态
        if (res_mark == biased_value) {
          return BIAS_REVOKED_AND_REBIASED;
        }
      } else {
        //不尝试获取偏向锁，则取消偏向锁
        markOop biased_value       = mark;
        markOop unbiased_prototype = markOopDesc::prototype()->set_age(mark->age());
        markOop res_mark = (markOop) Atomic::cmpxchg_ptr(unbiased_prototype, obj->mark_addr(), mark);
        //如果CAS操作成功，返回偏向锁撤销状态
        if (res_mark == biased_value) {
          return BIAS_REVOKED;
        }
      }
    }
  }
  ...
}

  //...接上一段代码

  //重偏向与撤销的逻辑
  //通过启发式的方式决定到底是执行撤销还是执行重偏向
  HeuristicsResult heuristics = update_heuristics(obj(), attempt_rebias);
  if (heuristics == HR_NOT_BIASED) {//决定不偏向
    return NOT_BIASED;
  } else if (heuristics == HR_SINGLE_REVOKE) {//决定撤销单个线程
    ...
    if (mark->biased_locker() == THREAD &&
        prototype_header->bias_epoch() == mark->bias_epoch()) {//需要撤销的是偏向当前线程的锁，当调用Object#hashcode方法时会走到这一步
      // 撤销逻辑1...
      ...
      return cond;
    } else {
      // 撤销逻辑2...
      ...
      return revoke.status_code();
    }
  }
  ...
  //批量撤销、批量重偏向的逻辑...
  ...
  return bulk_revoke.status_code();

//启发式的方式决定要做哪种操作
static HeuristicsResult update_heuristics(oop o, bool allow_rebias) {
  markOop mark = o->mark();
  if (!mark->has_bias_pattern()) {
    //不可偏向直接返回
    return HR_NOT_BIASED;
  }
  //控制撤销的次数
  // Heuristics to attempt to throttle the number of revocations.
  // Stages:
  // 1. Revoke the biases of all objects in the heap of this type,
  //    but allow rebiasing of those objects if unlocked.
  // 2. Revoke the biases of all objects in the heap of this type
  //    and don't allow rebiasing of these objects. Disable
  //    allocation of objects of that type with the bias bit set.
  // 锁对象的类
  Klass* k = o->klass();
  // 当前时间
  jlong cur_time = os::javaTimeMillis();
  // 该类上一次批量撤销的时间
  jlong last_bulk_revocation_time = k->last_biased_lock_bulk_revocation_time();
  // 该类偏向锁撤销的次数
  int revocation_count = k->biased_lock_revocation_count();
  //定义在globs.hpp,
  //BiasedLockingBulkRebiasThreshold(重偏向阈值,默认值为20),
  //BiasedLockingBulkRevokeThreshold(批量撤销阈值,默认值为40),
  //BiasedLockingDecayTime(开启一次新的批量重偏向距离上次批量重偏向的后的延迟时间,默认值为25000,
  //也就是开启批量重偏向后，经过了一段较长的时间（>=BiasedLockingDecayTime），撤销计数器才超过阈值，那我们会重置计数器。),
  //这些值可通过JVM启动参数改变
  if ((revocation_count >= BiasedLockingBulkRebiasThreshold) &&
      (revocation_count <  BiasedLockingBulkRevokeThreshold) &&
      (last_bulk_revocation_time != 0) &&
      (cur_time - last_bulk_revocation_time >= BiasedLockingDecayTime)) {
    // This is the first revocation we've seen in a while of an
    // object of this type since the last time we performed a bulk
    // rebiasing operation. The application is allocating objects in
    // bulk which are biased toward a thread and then handing them
    // off to another thread. We can cope with this allocation
    // pattern via the bulk rebiasing mechanism so we reset the
    // klass's revocation count rather than allow it to increase
    // monotonically. If we see the need to perform another bulk
    // rebias operation later, we will, and if subsequently we see
    // many more revocation operations in a short period of time we
    // will completely disable biasing for this type.
    //在执行了一定时间之内，执行的撤销次数没有超过阈值，那么认为可以优先执行bulk rebias,因此将计数回归原始值
    k->set_biased_lock_revocation_count(0);
    revocation_count = 0;
  }

  // Make revocation count saturate just beyond BiasedLockingBulkRevokeThreshold
  if (revocation_count <= BiasedLockingBulkRevokeThreshold) {
    //对执行撤销的次数进行计数
    revocation_count = k->atomic_incr_biased_lock_revocation_count();
  }

  if (revocation_count == BiasedLockingBulkRevokeThreshold) {
    //如果达到批量撤销阈值则返回HR_BULK_REVOKE，执行bulk revoke
    return HR_BULK_REVOKE;
  }

  if (revocation_count == BiasedLockingBulkRebiasThreshold) {
    //如果达到批量重偏向阈值则返回HR_BULK_REBIAS，执行bulk rebias
    return HR_BULK_REBIAS;
  }
  //默认执行单个对象的锁撤销
  return HR_SINGLE_REVOKE;
}

  //重偏向与撤销的逻辑
  //通过启发式的方式决定到底是执行撤销还是执行重偏向
  HeuristicsResult heuristics = update_heuristics(obj(), attempt_rebias);
  if (heuristics == HR_NOT_BIASED) {//决定不偏向
    return NOT_BIASED;
  } else if (heuristics == HR_SINGLE_REVOKE) {//决定撤销单个线程
    Klass *k = obj->klass();
    markOop prototype_header = k->prototype_header();
    if (mark->biased_locker() == THREAD &&
        prototype_header->bias_epoch() == mark->bias_epoch()) {// 走到这里说明需要撤销的是偏向当前线程的锁，当调用Object#hashcode方法时会走到这一步
      // 因为只要遍历当前线程的栈就好了，所以不需要等到safepoint再撤销。
      ResourceMark rm;
      if (TraceBiasedLocking) {
        tty->print_cr("Revoking bias by walking my own stack:");
      }
      BiasedLocking::Condition cond = revoke_bias(obj(), false, false, (JavaThread*) THREAD);
      ((JavaThread*) THREAD)->set_cached_monitor_info(NULL);
      assert(cond == BIAS_REVOKED, "why not?");
      return cond;
    } else {// 下面代码最终会在VM线程中的safepoint调用revoke_bias方法
      VM_RevokeBias revoke(&obj, (JavaThread*) THREAD);
      VMThread::execute(&revoke);
      return revoke.status_code();
    }
  }

  assert((heuristics == HR_BULK_REVOKE) ||
         (heuristics == HR_BULK_REBIAS), "?");
  //批量撤销、批量重偏向的逻辑
  VM_BulkRevokeBias bulk_revoke(&obj, (JavaThread*) THREAD,
                                (heuristics == HR_BULK_REBIAS),
                                attempt_rebias);
  VMThread::execute(&bulk_revoke);
  return bulk_revoke.status_code();

void VMThread::execute(VM_Operation* op) {
  Thread* t = Thread::current();
  //如果不是虚拟机线程，即普通Java线程
  if (!t->is_VM_thread()) {
    ...
    // 进行前置处理，根据返回值确定是否继续
    if (!op->doit_prologue()) {
      return;   // op was cancelled
    }
    ...
    // Add VM operation to list of waiting threads. We are guaranteed not to block while holding the
    // VMOperationQueue_lock, so we can block without a safepoint check. This allows vm operation requests
    // to be queued up during a safepoint synchronization.
    //添加到VM operation队列等待执行
    {
      VMOperationQueue_lock->lock_without_safepoint_check();
      bool ok = _vm_queue->add(op);
    op->set_timestamp(os::javaTimeMillis());
      VMOperationQueue_lock->notify();
      VMOperationQueue_lock->unlock();
      // VM_Operation got skipped
      if (!ok) {
        assert(concurrent, "can only skip concurrent tasks");
        if (op->is_cheap_allocated()) delete op;
        return;
      }
    }
    if (execute_epilog) {
      //  进行后置处理
      op->doit_epilogue();
    }
  } else {//如果已经是虚拟机线程
    // invoked by VM thread; usually nested VM operation
    ...
    op->evaluate();
    ...
  }
}

//  回调doit()
void VM_Operation::evaluate() {
  ...
  doit();
  ...
}

//  VM_RevokeBias继承了VM_Operation
//  并重写了doit_prologue()和doit()两个虚函数
class VM_RevokeBias : public VM_Operation {
...
public:
...
  virtual VMOp_Type type() const { return VMOp_RevokeBias; }

  // 如vm_operations.hpp注释描述的，若返回false则取消该VM操作
  virtual bool doit_prologue() {
    // Verify that there is actual work to do since the callers just
    // give us locked object(s). If we don't find any biased objects
    // there is nothing to do and we avoid a safepoint.
    //  若被锁对象不为空，则返回true继续后续逻辑即通过evaluate()回调doit()
    if (_obj != NULL) {
      markOop mark = (*_obj)()->mark();
      if (mark->has_bias_pattern()) {
        return true;
      }
    } else {
      for ( int i = 0 ; i < _objs->length(); i++ ) {
        //  遍历被锁对象，若存在可偏向状态，返回true继续后续逻辑即通过evaluate()回调doit()
        markOop mark = (_objs->at(i))()->mark();
        if (mark->has_bias_pattern()) {
          return true;
        }
      }
    }
    // 没有可偏向状态，返回true继续后续逻辑即通过evaluate()回调doit()
    return false;
  }

  virtual void doit() {
    //  被锁对象不为空
    if (_obj != NULL) {
      _status_code = revoke_bias((*_obj)(), false, false, _requesting_thread);
      ...
      return;
    } else {
      ...
    }
  }

  BiasedLocking::Condition status_code() const {
    return _status_code;
  }
};

static BiasedLocking::Condition revoke_bias(oop obj, bool allow_rebias, bool is_bulk, JavaThread* requesting_thread) {
  //  获取对象头
  markOop mark = obj->mark();
  if (!mark->has_bias_pattern()) {
    ...
    //  不是可偏向状态，返回
    return BiasedLocking::NOT_BIASED;
  }

  uint age = mark->age();
  //新建匿名偏向模式(可偏向)的头：分代年龄为age、可偏向(101)状态
  markOop   biased_prototype = markOopDesc::biased_locking_prototype()->set_age(age);
  //新建无锁模式的头:无hash、分代年龄为age、无锁(001)状态
  markOop unbiased_prototype = markOopDesc::prototype()->set_age(age);
  ....
  //获取偏向的线程
  JavaThread* biased_thread = mark->biased_locker();
  if (biased_thread == NULL) {
    // Object is anonymously biased. We can get here if, for
    // example, we revoke the bias due to an identity hash code
    // being computed for an object.
    //  没有偏向线程，identity hash code的计算会导致进入此分支
    if (!allow_rebias) {
      //  设置对象头为前面构建的无锁模式的头:无hash、分代年龄为age、无锁(001)状态
      obj->set_mark(unbiased_prototype);
    }
    //  偏向锁撤销完成
    return BiasedLocking::BIAS_REVOKED;
  }

  // Handle case where the thread toward which the object was biased has exited
  //对象头偏向线程是否活着
  bool thread_is_alive = false;
  if (requesting_thread == biased_thread) {
    //当前请求线程 就是 对象头偏向线程，说明偏向线程活着
    thread_is_alive = true;
  } else {
    //  遍历存活线程队列，看看能不能找到对象头偏向线程
    for (JavaThread* cur_thread = Threads::first(); cur_thread != NULL; cur_thread = cur_thread->next()) {
      if (cur_thread == biased_thread) {
        //  能找到说明对象头的偏向线程活着
        thread_is_alive = true;
        break;
      }
    }
  }
  //  如果对象头偏向线程已退出，则撤销偏向锁
  if (!thread_is_alive) {
    if (allow_rebias) {
      //  设置匿名偏向模式(可偏向)的头：分代年龄为age、可偏向(101)状态
      obj->set_mark(biased_prototype);
    } else {//由于传入该函数的allow_rebias==false，故走此分支
      //  设置无锁模式的头:无hash、分代年龄为age、无锁(001)状态
      obj->set_mark(unbiased_prototype);
    }
    //  偏向锁撤销完成
    return BiasedLocking::BIAS_REVOKED;
  }

  // 注释解释了逻辑：
  // Thread owning bias is alive.
  // Check to see whether it currently owns the lock and, if so,
  // write down the needed displaced headers to the thread's stack.
  // Otherwise, restore the object's header either to the unlocked
  // or unbiased state.

  //get_or_compute_monitor_info返回对象头偏向线程的所有的被锁住的对象的监视器信息，
  //即线程栈所有的Lock Record
  GrowableArray<MonitorInfo*>* cached_monitor_info = get_or_compute_monitor_info(biased_thread);
  BasicLock* highest_lock = NULL;
  //遍历偏向线程的线程栈的所有Lock Record，寻找当前被锁对象(obj)对应的Lock Record，
  //若找到，说明偏向的线程还在执行同步代码块中的代码，需要进行锁膨胀
  for (int i = 0; i < cached_monitor_info->length(); i++) {
    MonitorInfo* mon_info = cached_monitor_info->at(i);
    if (mon_info->owner() == obj) {// 找到了
      // Assume recursive case and fix up highest lock later

      // 需要锁膨胀，直接修改偏向线程栈中的Lock Record。
      // 由于要处理锁重入的case，在这里暂时只将Lock Record的Displaced Mark Word设置为null，
      // 其余处理Lock Record会在下面的代码中再进行
      markOop mark = markOopDesc::encode((BasicLock*) NULL);
      highest_lock = mon_info->lock();
      //设置栈中的Displaced Mark Word为NULL  
      highest_lock->set_displaced_header(mark);
    }
    ...
  }
  //  如果上面的过程找到了displaced_header，则highest_lock不为空
  //  说明当前撤销偏向的对象正在被偏向头里的线程锁定，即还在同步块中，
  //  进入下面分支，对正在被锁定的对象进行偏向锁撤销
  if (highest_lock != NULL) {
    // Fix up highest lock to contain displaced header and point
    // object at it
    // 如上面注释所言，用unbiased_prototype重新设置线程栈上的displaced header
    highest_lock->set_displaced_header(unbiased_prototype);
    // Reset object header to point to displaced mark.
    // 使对象头(mark)指向这个displaced header
    obj->release_set_mark(markOopDesc::encode(highest_lock));
    ...
    //对正在被锁定的对象进行偏向锁撤销完成，并没有改变对象头的锁状态，而是回到fast_enter继续锁膨胀过程
  } else {//  如果上面的过程没找displaced_header，说明当前撤销偏向锁
          //  的对象目前没有被锁定，即已经不在同步块中了，
          //  进入这个分支，对未锁定对象进行偏向撤销
    if (allow_rebias) {
      //设置为匿名偏向状态
      obj->set_mark(biased_prototype);
    } else {//由于传入该函数的allow_rebias==false，故走此分支
      // Store the unlocked value into the object's header.
      obj->set_mark(unbiased_prototype);
      //对未锁定对象进行偏向锁撤销完成，也表明对象成为了无锁模式:无hash、分代年龄为age、无锁(001)状态
    }
  }
  //  偏向撤销完成
  return BiasedLocking::BIAS_REVOKED;
}

//  Fast Monitor Enter/Exit
// This the fast monitor enter. The interpreter and compiler use
// some assembly copies of this code. Make sure update those code
// if the following function is changed. The implementation is
// extremely sensitive to race condition. Be careful.
void ObjectSynchronizer::fast_enter(Handle obj, BasicLock* lock,
                                    bool attempt_rebias, TRAPS) {
  //虚拟机参数判断是否开启了偏向锁
  if (UseBiasedLocking) {
    //如果不处于全局安全点，即正常的Java线程
    if (!SafepointSynchronize::is_at_safepoint()) {
      //通过`revoke_and_rebias`这个函数尝试撤销或重偏向偏向锁
      BiasedLocking::Condition cond = BiasedLocking::revoke_and_rebias(obj, attempt_rebias, THREAD);
      if (cond == BiasedLocking::BIAS_REVOKED_AND_REBIASED) {
        return;
      }
    } else {//如果在安全点，即VM线程，撤销偏向锁
      assert(!attempt_rebias, "can not rebias toward VM thread");
      BiasedLocking::revoke_at_safepoint(obj);
    }
    assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
  }
  slow_enter(obj, lock, THREAD);
}

// Interpreter/Compiler Slow Case
// This routine is used to handle interpreter/compiler slow case
// We don't need to use fast path here, because it must have been
// failed in the interpreter/compiler code.
void ObjectSynchronizer::slow_enter(Handle obj, BasicLock* lock, TRAPS) {
  markOop mark = obj->mark();
  assert(!mark->has_bias_pattern(), "should not see bias pattern here");
  if (mark->is_neutral()) {//如果是无锁状态, markword的biase_lock:0，lock:01
    // Anticipate successful CAS -- the ST of the displaced mark must
    // be visible <= the ST performed by the CAS.
    //通过CAS把mark保存到BasicLock对象的_displaced_header字段
    lock->set_displaced_header(mark);
    if (mark == obj()->cas_set_mark((markOop) lock, mark)) {
      TEVENT(slow_enter: release stacklock);
      return;
    }
    // Fall through to inflate() ...
  } else if (mark->has_locker() &&
             THREAD->is_lock_owned((address)mark->locker())) {//如果markword处于加锁状态、且markword中的ptr指针指向当前线程的栈帧，表示为轻量级锁重入，不需要争抢锁
    assert(lock != mark->locker(), "must not re-lock the same lock");
    assert(lock != (BasicLock*)obj->mark(), "don't relock with same BasicLock");
    lock->set_displaced_header(NULL);
    return;
  }
  
  // 这时候需要膨胀为重量级锁，膨胀前，设置Displaced Mark Word为一个特殊值，
  // 代表该锁正在用一个重量级锁的monitor
  // The object header will never be displaced to this lock,
  // so it does not matter what the value is, except that it
  // must be non-zero to avoid looking like a re-entrant lock,
  // and must not look locked either.
  lock->set_displaced_header(markOopDesc::unused_mark());
  //先调用inflate膨胀为重量级锁，该方法返回一个ObjectMonitor对象，然后调用其enter方法
  ObjectSynchronizer::inflate(THREAD,
                              obj(),
                              inflate_cause_monitor_enter)->enter(THREAD);
}

bool is_neutral()  const {
  // 这里的 biased_lock_mask_in_place 是 7, 即二进制111
  // unlocked_value 值是 1
  return (mask_bits(value(), biased_lock_mask_in_place) == unlocked_value);
}

unused:25 hash:31 -->| unused:1   age:4    biased_lock:1 lock:2 (normal object)
JavaThread*:54 epoch:2 unused:1   age:4    biased_lock:1 lock:2 (biased object)

BiasedLocking::Condition BiasedLocking::revoke_and_rebias(Handle obj, bool attempt_rebias, TRAPS) {
  ...
  //code 1：重偏向的逻辑
  HeuristicsResult heuristics = update_heuristics(obj(), attempt_rebias);
  // 非重偏向的逻辑
  ...

  assert((heuristics == HR_BULK_REVOKE) ||
         (heuristics == HR_BULK_REBIAS), "?");
   //code 2：批量撤销、批量重偏向的逻辑
  VM_BulkRevokeBias bulk_revoke(&obj, (JavaThread*) THREAD,
                                (heuristics == HR_BULK_REBIAS),
                                attempt_rebias);
  VMThread::execute(&bulk_revoke);
  return bulk_revoke.status_code();
}

//启发式的方式决定要做哪种操作
static HeuristicsResult update_heuristics(oop o, bool allow_rebias) {
  markOop mark = o->mark();
  if (!mark->has_bias_pattern()) {
    //不可偏向直接返回
    return HR_NOT_BIASED;
  }
  //控制撤销的次数
  // Heuristics to attempt to throttle the number of revocations.
  // Stages:
  // 1. Revoke the biases of all objects in the heap of this type,
  //    but allow rebiasing of those objects if unlocked.
  // 2. Revoke the biases of all objects in the heap of this type
  //    and don't allow rebiasing of these objects. Disable
  //    allocation of objects of that type with the bias bit set.
  // 锁对象的类
  Klass* k = o->klass();
  // 当前时间
  jlong cur_time = os::javaTimeMillis();
  // 该类上一次批量撤销的时间
  jlong last_bulk_revocation_time = k->last_biased_lock_bulk_revocation_time();
  // 该类偏向锁撤销的次数
  int revocation_count = k->biased_lock_revocation_count();
  //定义在globs.hpp,
  //BiasedLockingBulkRebiasThreshold(重偏向阈值,默认值为20),
  //BiasedLockingBulkRevokeThreshold(批量撤销阈值,默认值为40),
  //BiasedLockingDecayTime(开启一次新的批量重偏向距离上次批量重偏向的后的延迟时间,默认值为25000,
  //也就是开启批量重偏向后，经过了一段较长的时间（>=BiasedLockingDecayTime），撤销计数器才超过阈值，那我们会重置计数器。),
  //这些值可通过JVM启动参数改变
  if ((revocation_count >= BiasedLockingBulkRebiasThreshold) &&
      (revocation_count <  BiasedLockingBulkRevokeThreshold) &&
      (last_bulk_revocation_time != 0) &&
      (cur_time - last_bulk_revocation_time >= BiasedLockingDecayTime)) {
    // This is the first revocation we've seen in a while of an
    // object of this type since the last time we performed a bulk
    // rebiasing operation. The application is allocating objects in
    // bulk which are biased toward a thread and then handing them
    // off to another thread. We can cope with this allocation
    // pattern via the bulk rebiasing mechanism so we reset the
    // klass's revocation count rather than allow it to increase
    // monotonically. If we see the need to perform another bulk
    // rebias operation later, we will, and if subsequently we see
    // many more revocation operations in a short period of time we
    // will completely disable biasing for this type.
    //在执行了一定时间之内，执行的撤销次数没有超过阈值，那么认为可以优先执行bulk rebias,因此将计数回归原始值
    k->set_biased_lock_revocation_count(0);
    revocation_count = 0;
  }

  // Make revocation count saturate just beyond BiasedLockingBulkRevokeThreshold
  if (revocation_count <= BiasedLockingBulkRevokeThreshold) {
    //对执行撤销的次数进行计数
    revocation_count = k->atomic_incr_biased_lock_revocation_count();
  }

  if (revocation_count == BiasedLockingBulkRevokeThreshold) {
    //如果达到批量撤销阈值则返回HR_BULK_REVOKE，执行bulk revoke
    return HR_BULK_REVOKE;
  }

  if (revocation_count == BiasedLockingBulkRebiasThreshold) {
    //如果达到批量重偏向阈值则返回HR_BULK_REBIAS，执行bulk rebias
    return HR_BULK_REBIAS;
  }
  //默认执行单个对象的锁撤销
  return HR_SINGLE_REVOKE;
}

static BiasedLocking::Condition bulk_revoke_or_rebias_at_safepoint(oop o,
                                                                   bool bulk_rebias,
                                                                   bool attempt_rebias_of_object,
                                                                   JavaThread* requesting_thread) {
  ...
  jlong cur_time = os::javaTimeMillis();
  o->klass()->set_last_biased_lock_bulk_revocation_time(cur_time);


  Klass* k_o = o->klass();
  Klass* klass = k_o;

  if (bulk_rebias) {
    // 批量重偏向的逻辑
    if (klass->prototype_header()->has_bias_pattern()) {
      // 自增前类中的的epoch
      int prev_epoch = klass->prototype_header()->bias_epoch();
      // code 1：类中的epoch自增
      klass->set_prototype_header(klass->prototype_header()->incr_bias_epoch());
      int cur_epoch = klass->prototype_header()->bias_epoch();

      // code 2：遍历所有线程的栈，更新类型为该klass的所有锁实例的epoch
      for (JavaThread* thr = Threads::first(); thr != NULL; thr = thr->next()) {
        GrowableArray<MonitorInfo*>* cached_monitor_info = get_or_compute_monitor_info(thr);
        for (int i = 0; i < cached_monitor_info->length(); i++) {
          MonitorInfo* mon_info = cached_monitor_info->at(i);
          oop owner = mon_info->owner();
          markOop mark = owner->mark();
          if ((owner->klass() == k_o) && mark->has_bias_pattern()) {
            // We might have encountered this object already in the case of recursive locking
            assert(mark->bias_epoch() == prev_epoch || mark->bias_epoch() == cur_epoch, "error in bias epoch adjustment");
            owner->set_mark(mark->set_bias_epoch(cur_epoch));
          }
        }
      }
    }

    // 接下来对当前锁对象进行重偏向
    revoke_bias(o, attempt_rebias_of_object && klass->prototype_header()->has_bias_pattern(), true, requesting_thread);
  } else {
    ...

    // code 3：批量撤销的逻辑，将类中的偏向标记关闭，markOopDesc::prototype()返回的是一个关闭偏向模式的prototype
    klass->set_prototype_header(markOopDesc::prototype());

    // code 4：遍历所有线程的栈，撤销该类所有锁的偏向
    for (JavaThread* thr = Threads::first(); thr != NULL; thr = thr->next()) {
      GrowableArray<MonitorInfo*>* cached_monitor_info = get_or_compute_monitor_info(thr);
      for (int i = 0; i < cached_monitor_info->length(); i++) {
        MonitorInfo* mon_info = cached_monitor_info->at(i);
        oop owner = mon_info->owner();
        markOop mark = owner->mark();
        if ((owner->klass() == k_o) && mark->has_bias_pattern()) {
          revoke_bias(owner, false, true, requesting_thread);
        }
      }
    }

    // 撤销当前锁对象的偏向模式
    revoke_bias(o, false, true, requesting_thread);
  }

  ...
  
  BiasedLocking::Condition status_code = BiasedLocking::BIAS_REVOKED;

  if (attempt_rebias_of_object &&
      o->mark()->has_bias_pattern() &&
      klass->prototype_header()->has_bias_pattern()) {
    // 构造一个偏向请求线程的mark word
    markOop new_mark = markOopDesc::encode(requesting_thread, o->mark()->age(),
                                           klass->prototype_header()->bias_epoch());
    // 更新当前锁对象的mark word
    o->set_mark(new_mark);
    status_code = BiasedLocking::BIAS_REVOKED_AND_REBIASED;
    ...
  }

  ...

  return status_code;
}

ObjectMonitor * ATTR ObjectSynchronizer::inflate (Thread * Self, oop object) {
  ...

  for (;;) {
      const markOop mark = object->mark() ;
      assert (!mark->has_bias_pattern(), "invariant") ;

      // mark是以下状态中的一种：
      // *  Inflated（重量级锁状态）     - 直接返回
      // *  Stack-locked（轻量级锁状态） - 膨胀
      // *  INFLATING（膨胀中）    - 忙等待直到膨胀完成
      // *  Neutral（无锁状态）      - 膨胀
      // *  BIASED（偏向锁）       - 非法状态，在这里不会出现

      // CASE: inflated
      if (mark->has_monitor()) {
          // 已经是重量级锁状态了，直接返回
          ObjectMonitor * inf = mark->monitor() ;
          ...
          return inf ;
      }

      // CASE: inflation in progress
      if (mark == markOopDesc::INFLATING()) {
         // 正在膨胀中，说明另一个线程正在进行锁膨胀，continue重试
         TEVENT (Inflate: spin while INFLATING) ;
         // 在该方法中会进行spin/yield/park等操作完成自旋动作 
         ReadStableMark(object) ;
         continue ;
      }

      if (mark->has_locker()) {
          // 当前轻量级锁状态，先分配一个ObjectMonitor对象，并初始化值
          ObjectMonitor * m = omAlloc (Self) ;

          m->Recycle();
          m->_Responsible  = NULL ;
          m->OwnerIsThread = 0 ;
          m->_recursions   = 0 ;
          m->_SpinDuration = ObjectMonitor::Knob_SpinLimit ;   // Consider: maintain by type/class
          // 将锁对象的mark word设置为INFLATING (0)状态 
          markOop cmp = (markOop) Atomic::cmpxchg_ptr (markOopDesc::INFLATING(), object->mark_addr(), mark) ;
          if (cmp != mark) {
             omRelease (Self, m, true) ;
             continue ;       // Interference -- just retry
          }

          // 栈中的displaced mark word
          markOop dmw = mark->displaced_mark_helper() ;
          assert (dmw->is_neutral(), "invariant") ;

          // 设置monitor的字段
          m->set_header(dmw) ;
          // owner为Lock Record
          m->set_owner(mark->locker());
          m->set_object(object);
          ...
          // 将锁对象头设置为重量级锁状态
          object->release_set_mark(markOopDesc::encode(m));

         ...
          return m ;
      }

      // CASE: neutral

      // 分配以及初始化ObjectMonitor对象
      ObjectMonitor * m = omAlloc (Self) ;
      // prepare m for installation - set monitor to initial state
      m->Recycle();
      m->set_header(mark);
      // owner为NULL
      m->set_owner(NULL);
      m->set_object(object);
      m->OwnerIsThread = 1 ;
      m->_recursions   = 0 ;
      m->_Responsible  = NULL ;
      m->_SpinDuration = ObjectMonitor::Knob_SpinLimit ;       // consider: keep metastats by type/class
      // 用CAS替换对象头的mark word为重量级锁状态
      if (Atomic::cmpxchg_ptr (markOopDesc::encode(m), object->mark_addr(), mark) != mark) {
          // 不成功说明有另外一个线程在执行inflate，释放monitor对象
          m->set_object (NULL) ;
          m->set_owner  (NULL) ;
          m->OwnerIsThread = 0 ;
          m->Recycle() ;
          omRelease (Self, m, true) ;
          m = NULL ;
          continue ;
          // interference - the markword changed - just retry.
          // The state-transitions are one-way, so there's no chance of
          // live-lock -- "Inflated" is an absorbing state.
      }

      ...
      return m ;
  }
}

// Why do we CAS a 0 into the mark-word instead of just CASing the
// mark-word from the stack-locked value directly to the new inflated state?
// Consider what happens when a thread unlocks a stack-locked object.
// It attempts to use CAS to swing the displaced header value from the
// on-stack basiclock back into the object header.  Recall also that the
// header value (hashcode, etc) can reside in (a) the object header, or
// (b) a displaced header associated with the stack-lock, or (c) a displaced
// header in an objectMonitor.  The inflate() routine must copy the header
// value from the basiclock on the owner's stack to the objectMonitor, all
// the while preserving the hashCode stability invariants.  If the owner
// decides to release the lock while the value is 0, the unlock will fail
// and control will eventually pass from slow_exit() to inflate.  The owner
// will then spin, waiting for the 0 value to disappear.   Put another way,
// the 0 causes the owner to stall if the owner happens to try to
// drop the lock (restoring the header from the basiclock to the object)
// while inflation is in-progress.  This protocol avoids races that might
// would otherwise permit hashCode values to change or "flicker" for an object.
// Critically, while object->mark is 0 mark->displaced_mark_helper() is stable.
// 0 serves as a "BUSY" inflate-in-progress indicator.

void ATTR ObjectMonitor::enter(TRAPS) {

  Thread * const Self = THREAD ;
  void * cur ;
  // owner为null代表无锁状态，如果能CAS设置成功，则当前线程直接获得锁
  cur = Atomic::cmpxchg_ptr (Self, &_owner, NULL) ;
  if (cur == NULL) {
     ...
     return ;
  }
  // 如果是重入的情况
  if (cur == Self) {
     // TODO-FIXME: check for integer overflow!  BUGID 6557169.
     _recursions ++ ;
     return ;
  }
  // 当前线程是之前持有轻量级锁的线程。由轻量级锁膨胀且第一次调用enter方法，那cur是指向Lock Record的指针
  if (Self->is_lock_owned ((address)cur)) {
    assert (_recursions == 0, "internal state error");
    // 重入计数重置为1
    _recursions = 1 ;
    // 设置owner字段为当前线程（之前owner是指向Lock Record的指针）
    _owner = Self ;
    OwnerIsThread = 1 ;
    return ;
  }

  ...

  // 在调用系统的同步操作之前，先尝试自旋获得锁
  if (Knob_SpinEarly && TrySpin (Self) > 0) {
     ...
     //自旋的过程中获得了锁，则直接返回
     Self->_Stalled = 0 ;
     return ;
  }

  ...

  {
    ...

    for (;;) {
      jt->set_suspend_equivalent();
      // 在该方法中调用系统同步操作
      EnterI (THREAD) ;
      ...
    }
    Self->set_current_pending_monitor(NULL);

  }

  ...

}

class ObjectMonitor {
  ...
 public:
  // initialize the monitor, exception the semaphore, all other fields
  // are simple integers or pointers
  ObjectMonitor() {
    _header       = NULL;   // displaced object header word - mark
    _count        = 0;      // reference count to prevent reclaimation/deflation
                            // at stop-the-world time.  See deflate_idle_monitors().
                            // _count is approximately |_WaitSet| + |_EntryList|
    _waiters      = 0,      // number of waiting threads
    _recursions   = 0;      // recursion count, 0 for first entry
    _object       = NULL;   // backward object pointer - strong root
    _owner        = NULL;   // pointer to owning thread OR BasicLock
    _WaitSet      = NULL;   // LL of threads wait()ing on the monitor
    _WaitSetLock  = 0 ;     // protects Wait Queue - simple spinlock
    _Responsible  = NULL ;
    _succ         = NULL ;  // Heir presumptive thread - used for futile wakeup throttling
    _cxq          = NULL ;  // LL of recently-arrived threads blocked on entry.
                            // The list is actually composed of WaitNodes, acting
                            // as proxies for Threads.
    FreeNext      = NULL ;
    _EntryList    = NULL ;  // Threads blocked on entry or reentry.
    _SpinFreq     = 0 ;     // Spin 1-out-of-N attempts: success rate
    _SpinClock    = 0 ;
    OwnerIsThread = 0 ;     // _owner is (Thread *) vs SP/BasicLock
    _previous_owner_tid = 0;  // thread id of the previous owner of the monitor
  }
  ...
}

void ObjectMonitor::EnterI(TRAPS) {
  ...
  // Try the lock - TATAS
  if (TryLock (Self) > 0) {
    assert(_succ != Self, "invariant");
    assert(_owner == Self, "invariant");
    assert(_Responsible != Self, "invariant");
    return;
  }
  ...
  // We try one round of spinning *before* enqueueing Self.
  //
  // If the _owner is ready but OFFPROC we could use a YieldTo()
  // operation to donate the remainder of this thread's quantum
  // to the owner.  This has subtle but beneficial affinity
  // effects.
  if (TrySpin (Self) > 0) {
    assert(_owner == Self, "invariant");
    assert(_succ != Self, "invariant");
    assert(_Responsible != Self, "invariant");
    return;
  }
  ...
  ObjectWaiter node(Self);
  // Push "Self" onto the front of the _cxq.
  // Once on cxq/EntryList, Self stays on-queue until it acquires the lock.
  // Note that spinning tends to reduce the rate at which threads
  // enqueue and dequeue on EntryList|cxq.
  ObjectWaiter * nxt;
  for (;;) {
    node._next = nxt = _cxq;
    if (Atomic::cmpxchg(&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;
    ...
    if ((SyncFlags & 2) && _Responsible == NULL) {
      Atomic::replace_if_null(Self, &_Responsible);
    }
    // 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 > MAX_RECHECK_INTERVAL) {
        recheckInterval = MAX_RECHECK_INTERVAL;
      }
    } else {
      TEVENT(Inflated enter - park UNTIMED);
      Self->_ParkEvent->park();
    }
    if (TryLock(Self) > 0) break;
    ...
  }
  ...
  if (_Responsible == Self) {
    _Responsible = NULL;
  }
  // 善后处理，比如将当前线程从等待队列 CXQ 中移除
  ...
}

int ObjectMonitor::TryLock(Thread * Self) {
  void * own = _owner;
  if (own != NULL) return 0;
  if (Atomic::replace_if_null(Self, &_owner)) {
    // Either guarantee _recursions == 0 or set _recursions = 0.
    assert(_recursions == 0, "invariant");
    assert(_owner == Self, "invariant");
    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.
  return -1;
}

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
 public:
  ObjectWaiter(Thread* thread);
  void wait_reenter_begin(ObjectMonitor *mon);
  void wait_reenter_end(ObjectMonitor *mon);
};

// Push "Self" onto the front of the _cxq.
// Once on cxq/EntryList, Self stays on-queue until it acquires the lock.
// Note that spinning tends to reduce the rate at which threads
// enqueue and dequeue on EntryList|cxq.
ObjectWaiter * nxt;
for (;;) {
  node._next = nxt = _cxq;
  if (Atomic::cmpxchg(&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;
    ...
    if ((SyncFlags & 2) && _Responsible == NULL) {
      Atomic::replace_if_null(Self, &_Responsible);
    }
    // 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 > MAX_RECHECK_INTERVAL) {
        recheckInterval = MAX_RECHECK_INTERVAL;
      }
    } else {
      TEVENT(Inflated enter - park UNTIMED);
      Self->_ParkEvent->park();
    }
    if (TryLock(Self) > 0) break;
    ...
}

void os::PlatformEvent::park() {
  ...
  int status = pthread_mutex_lock(_mutex);
  ...
  status = pthread_cond_wait(_cond, _mutex);
  ...
  status = pthread_mutex_unlock(_mutex);
}

if (_Responsible == Self) {
    _Responsible = NULL;
}

void ObjectMonitor::exit(bool not_suspended, TRAPS) {
  for (;;) {
    ...
        ObjectWaiter * w = NULL;
    int QMode = Knob_QMode;

    if (QMode == 2 && _cxq != NULL) {
        ...
    }

    if (QMode == 3 && _cxq != NULL) {
        ...
    }

    if (QMode == 4 && _cxq != NULL) {
        ...
    }
    ...
    ExitEpilog(Self, w);
    return;
  }
}

// EntryList-cxq policy - queue discipline
static int Knob_QMode = 0;