BiasedLocking::Condition BiasedLocking::revoke_and_rebias(Handle obj, bool attempt_rebias, TRAPS) {
  assert(!SafepointSynchronize::is_at_safepoint(), "must not be called while at safepoint");
  
  //非fast_enter的调用可能会走if或者else if分支，此时attempt_rebias都是false，即这种情形下都是撤销偏向锁
  markOop mark = obj->mark();
  if (mark->is_biased_anonymously() && !attempt_rebias) {
    //如果obj的偏向锁未被占有且不需要获取偏向锁，则尝试将其恢复成默认的
    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);
    if (res_mark == biased_value) {
      //修改成功
      return BIAS_REVOKED;
    }
  } else if (mark->has_bias_pattern()) {
    //如果obj的偏向锁已经被占用了或者attempt_rebias为true
    Klass* k = obj->klass();
    //prototype_header变更只能在安全点下，变更时会将位于栈上的该klass的所有锁对象oop都做同样的变更
    //如果某个锁对象oop不在当时的调用栈帧中，则可能出现不一致
    markOop prototype_header = k->prototype_header();
    if (!prototype_header->has_bias_pattern()) {
      //如果prototype_header中没有偏向锁标识
      markOop biased_value       = mark;
      //将当前对象的对象头原子的修改成prototype_header，将其恢复成无锁状态
      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的值不等，说明更新prototype_header的epoch值时该对象不在任何Java线程栈帧中，即该对象的偏向锁实际已经释放了
      if (attempt_rebias) {
        //如果需要重新偏向
        assert(THREAD->is_Java_thread(), "");
        markOop biased_value       = mark;
        //生成一个新的偏向锁对象头，让当前线程占用该偏向锁
        markOop rebiased_prototype = markOopDesc::encode((JavaThread*) THREAD, mark->age(), prototype_header->bias_epoch());
        markOop res_mark = (markOop) Atomic::cmpxchg_ptr(rebiased_prototype, obj->mark_addr(), mark);
        if (res_mark == biased_value) {
          //如果修改成功
          return BIAS_REVOKED_AND_REBIASED;
        }
      } else {
        //attempt_rebias为false，则将对象头恢复成无锁状态
        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);
        if (res_mark == biased_value) {
          //修改成功
          return BIAS_REVOKED;
        }
      }
    }
  }
  
  //进入此逻辑的有以下几种情形：目标对象处于无锁状态；目标对象有偏向锁，其Klass的prototype_header也有偏向锁，且两者epoch一致。
  //如果是并发抢占偏向锁，则抢占失败的线程会进入此逻辑，通过VM_RevokeBias将偏向锁膨胀成轻量级锁，
  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()) {
      //如果目标对象的偏向锁被当前线程占有
      ResourceMark rm;
      if (TraceBiasedLocking) {
        tty->print_cr("Revoking bias by walking my own stack:");
      }
      /将偏向锁膨胀成轻量级锁或者撤销
      BiasedLocking::Condition cond = revoke_bias(obj(), false, false, (JavaThread*) THREAD);
      //将cached_monitor_info置为NULL，revoke_bias方法会设置该属性
      ((JavaThread*) THREAD)->set_cached_monitor_info(NULL);
      assert(cond == BIAS_REVOKED, "why not?");
      return cond;
    } else {
    //如果占用偏向锁的不是当前线程，底层也是调用revoke_bias，撤销偏向锁或者将其膨胀成轻量级锁
      //因为是修改其他线程占用的obj，为了安全需要在安全点下执行，借此暂停持有该偏向锁的线程，注意这个任务并不是立即执行，而是有一个短暂的延时
      VM_RevokeBias revoke(&obj, (JavaThread*) THREAD);
      VMThread::execute(&revoke);
      return revoke.status_code();
    }
  }
 
  assert((heuristics == HR_BULK_REVOKE) ||
         (heuristics == HR_BULK_REBIAS), "?");
  //执行批量撤销或者重偏向，底层调用bulk_revoke_or_rebias_at_safepoint
  //同一个Klass的多个锁对象oop累计调用update_heuristics超过一定次数就会返回HR_BULK_REBIAS，通过VM_BulkRevokeBias将Klass和对应的多个位于调用栈帧中的锁对象oop的epoch值增加，这样没有为调用栈帧中也是该Klass的锁对象oop就会被用于重新获取偏向锁，减少update_heuristics的调用
  //如果调用更加频繁，则返回HR_BULK_REVOKE，将该Klass的prototype_header和对应的多个位于调用栈帧中的锁对象oop恢复成无锁状态，因为频繁的执行此逻辑说明当前的并发调用场景已经不适用于偏向锁了       
  VM_BulkRevokeBias bulk_revoke(&obj, (JavaThread*) THREAD,
                                (heuristics == HR_BULK_REBIAS),
                                attempt_rebias);
  VMThread::execute(&bulk_revoke);
  return bulk_revoke.status_code();
}