JVM同步方法之偏向锁

address TemplateInterpreterGenerator::generate_normal_entry(bool synchronized) {
  ......
  if (synchronized) {
    // Allocate monitor and lock method
    lock_method();
  } else {
    ......
  }
  // 下面会开始执行方法的字节码
  ......
 
}

void TemplateInterpreterGenerator::lock_method() {
  
  .......
  // get synchronization object
  {
    Label done;
    __ movl(rax, access_flags);
    __ testl(rax, JVM_ACC_STATIC);
    // get receiver (assume this is frequent case)
    // 局部变量表中第一个变量，存放着即将锁的对象指针，移动到rax中
    __ movptr(rax, Address(rlocals, Interpreter::local_offset_in_bytes(0)));
    __ jcc(Assembler::zero, done);
    __ load_mirror(rax, rbx);

    __ bind(done);
  }

  // add space for monitor & lock
  // 在当前栈帧中分配一个空间，用于分配一个BasicObjectLock对象
  __ subptr(rsp, entry_size); // add space for a monitor entry
  __ movptr(monitor_block_top, rsp);  // set new monitor block top
  // store object
  // 将要锁的对象指针移动到分配的BasicObjectLock中的obj变量
  __ movptr(Address(rsp, BasicObjectLock::obj_offset_in_bytes()), rax);
  const Register lockreg = NOT_LP64(rdx) LP64_ONLY(c_rarg1);
  // 将分配的BasicObjectLock的指针移动到lockreg寄存器中
  __ movptr(lockreg, rsp); // object address
  // 加锁
  __ lock_object(lockreg);
}

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);
    }
    ......
    ......

    // 直接跳到这，需要进入InterpreterRuntime::monitorenter（）中去获取锁。
    bind(slow_case);
    // Call the runtime routine for slow case
    call_VM(noreg,
            CAST_FROM_FN_PTR(address, InterpreterRuntime::monitorenter),
            lock_reg);
    // 直接跳到这表明获取锁成功，接下来就会返回到entry_point例程进行字节码的执行了。
    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；否则即为偏向锁状态，接着往下走。
  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);

  // 将当前线程id和类的prototype_header相或，这样得到的markOop为（当前线程id + prototype_header中的（epoch + 分代年龄 + 偏向锁标志 + 锁标志位）），注意prototype_header的分代年龄那4个字节为0
  orptr(tmp_reg, r15_thread);
  // 将上面计算得到的结果与锁对象的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);

  // 将header_reg和111相与，如果结果不为0，则表明header_reg后三位存在不为0的位，证明之前进行异或时，类的prototype_header后面三位与对象markOop的后三位不相等，但是能走到这，表明对象markword后三位为101，即偏向模式。现在类的prototype_header和对象markOop后三位不相等，即对象所属类不再支持偏向，发生了bulk_revoke，所以需要对当前对象进行偏向锁的撤销；否则表明目前该类还支持偏向锁，接着往下走。
  testptr(header_reg, markOopDesc::biased_lock_mask_in_place);
  jccb(Assembler::notZero, try_revoke_bias);

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

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

  bind(try_rebias);
  // 将锁对象所属类的prototype_header送入tmp_reg。
  load_prototype_header(tmp_reg, obj_reg);
  // 尝试用CAS操作，使对象的markOop重置为无线程id的偏向锁态，即不偏向任何线程。
  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（）方法中，继续轻量级锁的获取。