• 极客专栏正式上线!欢迎访问 https://www.jikewenku.com/topic.html
  • 极客专栏正式上线!欢迎访问 https://www.jikewenku.com/topic.html

死磕Synchronized底层实现–偏向锁

技术杂谈 勤劳的小蚂蚁 4个月前 (01-03) 125次浏览 已收录 0个评论 扫描二维码

本文为synchronized系列第二篇。主要内容为分析偏向锁的实现。
偏向锁的诞生背景和基本原理在上文中已经讲过了,强烈建议在有看过上篇文章的基础下阅读本文。
更多文章见个人博客:
本系列文章将对HotSpot的synchronized锁实现进行全面分析,内容包括偏向锁、轻量级锁、重量级锁的加锁、解锁、锁升级流程的原理及源码分析,希望给在研究synchronized路上的同学一些帮助。
本文将分为几块内容:
  • 偏向锁的入口
  • 偏向锁的获取流程
  • 偏向锁的撤销流程
  • 偏向锁的释放流程
  • 偏向锁的批量重偏向和批量撤销
本文分析的JVM版本是JVM8,具体版本号以及代码可以在这里看到。
偏向锁入口 目前网上的很多文章,关于偏向锁源码入口都找错地方了,导致我之前对于偏向锁的很多逻辑一直想不通,走了很多弯路。
synchronized分为synchronized代码块和synchronized方法,其底层获取锁的逻辑都是一样的,本文讲解的是synchronized代码块的实现。上篇文章也说过,synchronized代码块是由monitorenter和monitorexit两个指令实现的。
关于HotSpot虚拟机中获取锁的入口,网上很多文章要么给出的方法入口为interpreterRuntime.cpp#monitorenter,要么给出的入口为bytecodeInterpreter.cpp#1816。包括占小狼的这篇文章关于锁入口的位置说法也是有问题的(当然文章还是很好的,在我刚开始研究synchronized的时候,小狼哥的这篇文章给了我很多帮助)。
要找锁的入口,肯定是要在源码中找到对monitorenter指令解析的地方。在HotSpot的中有两处地方对monitorenter指令进行解析:一个是在bytecodeInterpreter.cpp#1816 ,另一个是在templateTablex8664.cpp#3667。
前者是JVM中的字节码解释器(bytecodeInterpreter),用C++实现了每条JVM指令(如monitorenter、invokevirtual等),其优点是实现相对简单且容易理解,缺点是执行慢。后者是模板解释器(templateInterpreter),其对每个指令都写了一段对应的汇编代码,启动时将每个指令与对应汇编代码入口绑定,可以说是效率做到了极致。模板解释器的实现可以看这篇文章,在研究的过程中也请教过文章作者‘汪先生’一些问题,这里感谢一下。
在HotSpot中,只用到了模板解释器,字节码解释器根本就没用到,R大的读书笔记中说的很清楚了,大家可以看看,这里不再赘述。
所以montorenter的解析入口在模板解释器中,其代码位于templateTablex8664.cpp#3667。通过调用路径:templateTablex8664#monitorenter->interpmasmx8664#lockobject进入到偏向锁入口macroAssemblerx86#biasedlockingenter,在这里大家可以看到会生成对应的汇编代码。需要注意的是,不是说每次解析monitorenter指令都会调用biasedlocking_enter,而是只会在JVM启动的时候调用该方法生成汇编代码,之后对指令的解析是通过直接执行汇编代码。
其实bytecodeInterpreter的逻辑和templateInterpreter的逻辑是大同小异的,因为templateInterpreter中都是汇编代码,比较晦涩,所以看bytecodeInterpreter的实现会便于理解一点。但这里有个坑,在jdk8u之前,bytecodeInterpreter并没有实现偏向锁的逻辑。
我之前看的JDK8-87ee5ee27509这个版本就没有实现偏向锁的逻辑,导致我看了很久都没看懂。在这个commit中对bytecodeInterpreter加入了偏向锁的支持,我大致了看了下和templateInterpreter对比除了栈结构不同外,其他逻辑大致相同,所以下文就按bytecodeInterpreter中的代码对偏向锁逻辑进行讲解。
templateInterpreter的汇编代码讲解可以看这篇文章,其实汇编源码中都有英文注释,了解了汇编几个基本指令的作用再结合注释理解起来也不是很难。

偏向锁获取流程

下面开始偏向锁获取流程分析,代码在bytecodeInterpreter.cpp#1816。注意本文代码都有所删减。
  1. CASE(_monitorenter):{
  2.  // lockee 就是锁对象
  3.  oop lockee = STACK_OBJECT(-1);
  4.  // derefing's lockee ought to provoke implicit null check
  5.  CHECK_NULL(lockee);
  6.  // code 1:找到一个空闲的Lock Record
  7.  BasicObjectLock* limit = istate->monitor_base();
  8.  BasicObjectLock* most_recent =(BasicObjectLock*) istate->stack_base();
  9.  BasicObjectLock* entry = NULL;
  10.  while(most_recent != limit ){
  11.    if(most_recent->obj()== NULL) entry = most_recent;
  12.    elseif(most_recent->obj()== lockee)break;
  13.    most_recent++;
  14.  }
  15.  //entry不为null,代表还有空闲的Lock Record
  16.  if(entry != NULL){
  17.    // code 2:将Lock Record的obj指针指向锁对象
  18.    entry->set_obj(lockee);
  19.    int success =false;
  20.    uintptr_t epoch_mask_in_place =(uintptr_t)markOopDesc::epoch_mask_in_place;
  21.    // markoop即对象头的mark word
  22.    markOop mark = lockee->mark();
  23.    intptr_t hash =(intptr_t) markOopDesc::no_hash;
  24.    // code 3:如果锁对象的mark word的状态是偏向模式
  25.    if(mark->has_bias_pattern()){
  26.      uintptr_t thread_ident;
  27.      uintptr_t anticipated_bias_locking_value;
  28.      thread_ident =(uintptr_t)istate->thread();
  29.     // code 4:这里有几步操作,下文分析
  30.      anticipated_bias_locking_value =
  31.        (((uintptr_t)lockee->klass()->prototype_header()| thread_ident)^(uintptr_t)mark)&
  32.        ~((uintptr_t) markOopDesc::age_mask_in_place);
  33.     // code 5:如果偏向的线程是自己且epoch等于class的epoch
  34.      if  (anticipated_bias_locking_value ==0){
  35.        // already biased towards this thread, nothing to do
  36.        if(PrintBiasedLockingStatistics){
  37.          (*BiasedLocking::biased_lock_entry_count_addr())++;
  38.        }
  39.        success =true;
  40.      }
  41.       // code 6:如果偏向模式关闭,则尝试撤销偏向锁
  42.      elseif((anticipated_bias_locking_value & markOopDesc::biased_lock_mask_in_place)!=0){
  43.        markOop header = lockee->klass()->prototype_header();
  44.        if(hash != markOopDesc::no_hash){
  45.          header = header->copy_set_hash(hash);
  46.        }
  47.        // 利用CAS操作将mark word替换为class中的mark word
  48.        if(Atomic::cmpxchg_ptr(header, lockee->mark_addr(), mark)== mark){
  49.          if(PrintBiasedLockingStatistics)
  50.            (*BiasedLocking::revoked_lock_entry_count_addr())++;
  51.        }
  52.      }
  53.         // code 7:如果epoch不等于class中的epoch,则尝试重偏向
  54.      elseif((anticipated_bias_locking_value & epoch_mask_in_place)!=0){
  55.        // 构造一个偏向当前线程的mark word
  56.        markOop new_header =(markOop)((intptr_t) lockee->klass()->prototype_header()| thread_ident);
  57.        if(hash != markOopDesc::no_hash){
  58.          new_header = new_header->copy_set_hash(hash);
  59.        }
  60.        // CAS替换对象头的mark word  
  61.        if(Atomic::cmpxchg_ptr((void*)new_header, lockee->mark_addr(), mark)== mark){
  62.          if(PrintBiasedLockingStatistics)
  63.            (*BiasedLocking::rebiased_lock_entry_count_addr())++;
  64.        }
  65.        else{
  66.          // 重偏向失败,代表存在多线程竞争,则调用monitorenter方法进行锁升级
  67.          CALL_VM(InterpreterRuntime::monitorenter(THREAD, entry), handle_exception);
  68.        }
  69.        success =true;
  70.      }
  71.      else{
  72.         // 走到这里说明当前要么偏向别的线程,要么是匿名偏向(即没有偏向任何线程)
  73.           // code 8:下面构建一个匿名偏向的mark word,尝试用CAS指令替换掉锁对象的mark word
  74.        markOop header =(markOop)((uintptr_t) mark &((uintptr_t)markOopDesc::biased_lock_mask_in_place |(uintptr_t)markOopDesc::age_mask_in_place |epoch_mask_in_place));
  75.        if(hash != markOopDesc::no_hash){
  76.          header = header->copy_set_hash(hash);
  77.        }
  78.        markOop new_header =(markOop)((uintptr_t) header | thread_ident);
  79.        // debugging hint
  80.        DEBUG_ONLY(entry->lock()->set_displaced_header((markOop)(uintptr_t)0xdeaddead);)
  81.        if(Atomic::cmpxchg_ptr((void*)new_header, lockee->mark_addr(), header)== header){
  82.           // CAS修改成功
  83.          if(PrintBiasedLockingStatistics)
  84.            (*BiasedLocking::anonymously_biased_lock_entry_count_addr())++;
  85.        }
  86.        else{
  87.          // 如果修改失败说明存在多线程竞争,所以进入monitorenter方法
  88.          CALL_VM(InterpreterRuntime::monitorenter(THREAD, entry), handle_exception);
  89.        }
  90.        success =true;
  91.      }
  92.    }
  93.    // 如果偏向线程不是当前线程或没有开启偏向模式等原因都会导致success==false
  94.    if(!success){
  95.      // 轻量级锁的逻辑
  96.      //code 9: 构造一个无锁状态的Displaced Mark Word,并将Lock Record的lock指向它
  97.      markOop displaced = lockee->mark()->set_unlocked();
  98.      entry->lock()->set_displaced_header(displaced);
  99.      //如果指定了-XX:+UseHeavyMonitors,则call_vm=true,代表禁用偏向锁和轻量级锁
  100.      bool call_vm =UseHeavyMonitors;
  101.      // 利用CAS将对象头的mark word替换为指向Lock Record的指针
  102.      if(call_vm ||Atomic::cmpxchg_ptr(entry, lockee->mark_addr(), displaced)!= displaced){
  103.        // 判断是不是锁重入
  104.        if(!call_vm && THREAD->is_lock_owned((address) displaced->clear_lock_bits())){        //code 10: 如果是锁重入,则直接将Displaced Mark Word设置为null
  105.          entry->lock()->set_displaced_header(NULL);
  106.        }else{
  107.          CALL_VM(InterpreterRuntime::monitorenter(THREAD, entry), handle_exception);
  108.        }
  109.      }
  110.    }
  111.    UPDATE_PC_AND_TOS_AND_CONTINUE(1,-1);
  112.  }else{
  113.    // lock record不够,重新执行
  114.    istate->set_msg(more_monitors);
  115.    UPDATE_PC_AND_RETURN(0);// Re-execute
  116.  }
  117. }
再回顾下对象头中mark word的格式:
JVM中的每个类也有一个类似mark word的prototypeheader,用来标记该class的epoch和偏向开关等信息。上面的代码中lockee->klass()->prototypeheader()即获取class的prototype_header。
code 1,从当前线程的栈中找到一个空闲的Lock Record(即代码中的BasicObjectLock,下文都用Lock Record代指),判断Lock Record是否空闲的依据是其obj字段 是否为null。注意这里是按内存地址从低往高找到最后一个可用的Lock Record,换而言之,就是找到内存地址最高的可用Lock Record。
code 2,获取到Lock Record后,首先要做的就是为其obj字段赋值。
code 3,判断锁对象的mark word是否是偏向模式,即低3位是否为101。
code 4,这里有几步位运算的操作 anticipatedbiaslockingvalue = (((uintptrt)lockee->klass()->prototypeheader() | threadident) ^ (uintptrt)mark) &  ~((uintptrt) markOopDesc::agemaskin_place); 这个位运算可以分为3个部分。
第一部分((uintptrt)lockee->klass()->prototypeheader() | threadident) 将当前线程id和类的prototypeheader相或,这样得到的值为(当前线程id + prototypeheader中的(epoch + 分代年龄 + 偏向锁标志 + 锁标志位)),注意prototypeheader的分代年龄那4个字节为0
第二部分 ^ (uintptr_t)mark 将上面计算得到的结果与锁对象的markOop进行异或,相等的位全部被置为0,只剩下不相等的位。
第三部分 & ~((uintptrt) markOopDesc::agemaskinplace) markOopDesc::agemaskin_place为…0001111000,取反后,变成了…1110000111,除了分代年龄那4位,其他位全为1;将取反后的结果再与上面的结果相与,将上面异或得到的结果中分代年龄给忽略掉。
code 5,anticipatedbiaslocking_value==0代表偏向的线程是当前线程且mark word的epoch等于class的epoch,这种情况下什么都不用做。
code 6,(anticipatedbiaslockingvalue & markOopDesc::biasedlockmaskinplace) != 0代表class的prototypeheader或对象的mark word中偏向模式是关闭的,又因为能走到这已经通过了mark->hasbiaspattern()判断,即对象的mark word中偏向模式是开启的,那也就是说class的prototype_header不是偏向模式。
然后利用CAS指令Atomic::cmpxchgptr(header, lockee->markaddr(), mark) == mark撤销偏向锁,我们知道CAS会有几个参数,1是预期的原值,2是预期修改后的值 ,3是要修改的对象,与之对应,cmpxchg_ptr方法第一个参数是预期修改后的值,第2个参数是修改的对象,第3个参数是预期原值,方法返回实际原值,如果等于预期原值则说明修改成功。
code 7,如果epoch已过期,则需要重偏向,利用CAS指令将锁对象的mark word替换为一个偏向当前线程且epoch为类的epoch的新的mark word。
code 8,CAS将偏向线程改为当前线程,如果当前是匿名偏向则能修改成功,否则进入锁升级的逻辑。
code 9,这一步已经是轻量级锁的逻辑了。从上图的mark word的格式可以看到,轻量级锁中mark word存的是指向Lock Record的指针。这里构造一个无锁状态的mark word,然后存储到Lock Record(Lock Record的格式可以看第一篇文章)。设置mark word是无锁状态的原因是:轻量级锁解锁时是将对象头的mark word设置为Lock Record中的Displaced Mark Word,所以创建时设置为无锁状态,解锁时直接用CAS替换就好了。
code 10, 如果是锁重入,则将Lock Record的Displaced Mark Word设置为null,起到一个锁重入计数的作用。
以上是偏向锁加锁的流程(包括部分轻量级锁的加锁流程),如果当前锁已偏向其他线程||epoch值过期||偏向模式关闭||获取偏向锁的过程中存在并发冲突,都会进入到InterpreterRuntime::monitorenter方法, 在该方法中会对偏向锁撤销和升级。

偏向锁的撤销

这里说的撤销是指在获取偏向锁的过程因为不满足条件导致要将锁对象改为非偏向锁状态;释放是指退出同步块时的过程,释放锁的逻辑会在下一小节阐述。请读者注意本文中撤销与释放的区别。
如果获取偏向锁失败会进入到InterpreterRuntime::monitorenter方法
  1. IRT_ENTRY_NO_ASYNC(void,InterpreterRuntime::monitorenter(JavaThread* thread,BasicObjectLock* elem))
  2.  ...
  3.  Handle h_obj(thread, elem->obj());
  4.  assert(Universe::heap()->is_in_reserved_or_null(h_obj()),
  5.         "must be NULL or an object");
  6.  if(UseBiasedLocking){
  7.    // Retry fast entry if bias is revoked to avoid unnecessary inflation
  8.    ObjectSynchronizer::fast_enter(h_obj, elem->lock(),true, CHECK);
  9.  }else{
  10.    ObjectSynchronizer::slow_enter(h_obj, elem->lock(), CHECK);
  11.  }
  12.  ...
  13. IRT_END
可以看到如果开启了JVM偏向锁,那会进入到ObjectSynchronizer::fast_enter方法中。
  1. voidObjectSynchronizer::fast_enter(Handle obj,BasicLock*lock,bool attempt_rebias, TRAPS){
  2. if(UseBiasedLocking){
  3.    if(!SafepointSynchronize::is_at_safepoint()){
  4.      BiasedLocking::Condition cond =BiasedLocking::revoke_and_rebias(obj, attempt_rebias, THREAD);
  5.      if(cond ==BiasedLocking::BIAS_REVOKED_AND_REBIASED){
  6.        return;
  7.      }
  8.    }else{
  9.      assert(!attempt_rebias,"can not rebias toward VM thread");
  10.      BiasedLocking::revoke_at_safepoint(obj);
  11.    }
  12.    assert(!obj->mark()->has_bias_pattern(),"biases should be revoked by now");
  13. }
  14. slow_enter (obj,lock, THREAD);
  15. }
如果是正常的Java线程,会走上面的逻辑进入到BiasedLocking::revokeandrebias方法,如果是VM线程则会走到下面的BiasedLocking::revokeatsafepoint。我们主要看BiasedLocking::revokeandrebias方法。这个方法的主要作用像它的方法名:撤销或者重偏向,第一个参数封装了锁对象和当前线程,第二个参数代表是否允许重偏向,这里是true。
  1. BiasedLocking::ConditionBiasedLocking::revoke_and_rebias(Handle obj,bool attempt_rebias, TRAPS){
  2.  assert(!SafepointSynchronize::is_at_safepoint(),"must not be called while at safepoint");
  3.  markOop mark = obj->mark();
  4.  if(mark->is_biased_anonymously()&&!attempt_rebias){
  5.     //如果是匿名偏向且attempt_rebias==false会走到这里,如锁对象的hashcode方法被调用会出现这种情况,需要撤销偏向锁。
  6.    markOop biased_value       = mark;
  7.    markOop unbiased_prototype = markOopDesc::prototype()->set_age(mark->age());
  8.    markOop res_mark =(markOop)Atomic::cmpxchg_ptr(unbiased_prototype, obj->mark_addr(), mark);
  9.    if(res_mark == biased_value){
  10.      return BIAS_REVOKED;
  11.    }
  12.  }elseif(mark->has_bias_pattern()){
  13.    // 锁对象开启了偏向模式会走到这里
  14.    Klass* k = obj->klass();
  15.    markOop prototype_header = k->prototype_header();
  16.    //code 1: 如果对应class关闭了偏向模式
  17.    if(!prototype_header->has_bias_pattern()){
  18.      markOop biased_value       = mark;
  19.      markOop res_mark =(markOop)Atomic::cmpxchg_ptr(prototype_header, obj->mark_addr(), mark);
  20.      assert(!(*(obj->mark_addr()))->has_bias_pattern(),"even if we raced, should still be revoked");
  21.      return BIAS_REVOKED;
  22.    //code2: 如果epoch过期
  23.    }elseif(prototype_header->bias_epoch()!= mark->bias_epoch()){
  24.      if(attempt_rebias){
  25.        assert(THREAD->is_Java_thread(),"");
  26.        markOop biased_value       = mark;
  27.        markOop rebiased_prototype = markOopDesc::encode((JavaThread*) THREAD, mark->age(), prototype_header->bias_epoch());
  28.        markOop res_mark =(markOop)Atomic::cmpxchg_ptr(rebiased_prototype, obj->mark_addr(), mark);
  29.        if(res_mark == biased_value){
  30.          return BIAS_REVOKED_AND_REBIASED;
  31.        }
  32.      }else{
  33.        markOop biased_value       = mark;
  34.        markOop unbiased_prototype = markOopDesc::prototype()->set_age(mark->age());
  35.        markOop res_mark =(markOop)Atomic::cmpxchg_ptr(unbiased_prototype, obj->mark_addr(), mark);
  36.        if(res_mark == biased_value){
  37.          return BIAS_REVOKED;
  38.        }
  39.      }
  40.    }
  41.  }
  42.  //code 3:批量重偏向与批量撤销的逻辑
  43.  HeuristicsResult heuristics = update_heuristics(obj(), attempt_rebias);
  44.  if(heuristics == HR_NOT_BIASED){
  45.    return NOT_BIASED;
  46.  }elseif(heuristics == HR_SINGLE_REVOKE){
  47.    //code 4:撤销单个线程
  48.    Klass*k = obj->klass();
  49.    markOop prototype_header = k->prototype_header();
  50.    if(mark->biased_locker()== THREAD &&
  51.        prototype_header->bias_epoch()== mark->bias_epoch()){
  52.      // 走到这里说明需要撤销的是偏向当前线程的锁,当调用Object#hashcode方法时会走到这一步
  53.      // 因为只要遍历当前线程的栈就好了,所以不需要等到safepoint再撤销。
  54.      ResourceMark rm;
  55.      if(TraceBiasedLocking){
  56.        tty->print_cr("Revoking bias by walking my own stack:");
  57.      }
  58.      BiasedLocking::Condition cond = revoke_bias(obj(),false,false,(JavaThread*) THREAD);
  59.      ((JavaThread*) THREAD)->set_cached_monitor_info(NULL);
  60.      assert(cond == BIAS_REVOKED,"why not?");
  61.      return cond;
  62.    }else{
  63.      // 下面代码最终会在VM线程中的safepoint调用revoke_bias方法
  64.      VM_RevokeBias revoke(&obj,(JavaThread*) THREAD);
  65.      VMThread::execute(&revoke);
  66.      return revoke.status_code();
  67.    }
  68.  }
  69.  assert((heuristics == HR_BULK_REVOKE)||
  70.         (heuristics == HR_BULK_REBIAS),"?");
  71.   //code5:批量撤销、批量重偏向的逻辑
  72.  VM_BulkRevokeBias bulk_revoke(&obj,(JavaThread*) THREAD,
  73.                                (heuristics == HR_BULK_REBIAS),
  74.                                attempt_rebias);
  75.  VMThread::execute(&bulk_revoke);
  76.  return bulk_revoke.status_code();
  77. }
会走到该方法的逻辑有很多,我们只分析最常见的情况:假设锁已经偏向线程A,这时B线程尝试获得锁。
上面的code 1,code 2B线程都不会走到,最终会走到code 4处,如果要撤销的锁偏向的是当前线程则直接调用revoke_bias撤销偏向锁,否则会将该操作push到VM Thread中等到safepoint的时候再执行。
关于VM Thread这里介绍下:在JVM中有个专门的VM Thread,该线程会源源不断的从VMOperationQueue中取出请求,比如GC请求。对于需要safepoint的操作(VMOperationevaluateat_safepoint返回true)必须要等到所有的Java线程进入到safepoint才开始执行。 关于safepoint可以参考下这篇文章
接下来我们着重分析下revoke_bias方法。第一个参数为锁对象,第2、3个参数为都为false。
  1. staticBiasedLocking::Condition revoke_bias(oop obj,bool allow_rebias,bool is_bulk,JavaThread* requesting_thread){
  2.  markOop mark = obj->mark();
  3.  // 如果没有开启偏向模式,则直接返回NOT_BIASED
  4.  if(!mark->has_bias_pattern()){
  5.    ...
  6.    returnBiasedLocking::NOT_BIASED;
  7.  }
  8.  uint age = mark->age();
  9.  // 构建两个mark word,一个是匿名偏向模式(101),一个是无锁模式(001)
  10.  markOop   biased_prototype = markOopDesc::biased_locking_prototype()->set_age(age);
  11.  markOop unbiased_prototype = markOopDesc::prototype()->set_age(age);
  12.  ...
  13.  JavaThread* biased_thread = mark->biased_locker();
  14.  if(biased_thread == NULL){
  15.     // 匿名偏向。当调用锁对象的hashcode()方法可能会导致走到这个逻辑
  16.     // 如果不允许重偏向,则将对象的mark word设置为无锁模式
  17.    if(!allow_rebias){
  18.      obj->set_mark(unbiased_prototype);
  19.    }
  20.    ...
  21.    returnBiasedLocking::BIAS_REVOKED;
  22.  }
  23.  // code 1:判断偏向线程是否还存活
  24.  bool thread_is_alive =false;
  25.  // 如果当前线程就是偏向线程
  26.  if(requesting_thread == biased_thread){
  27.    thread_is_alive =true;
  28.  }else{
  29.     // 遍历当前jvm的所有线程,如果能找到,则说明偏向的线程还存活
  30.    for(JavaThread* cur_thread =Threads::first(); cur_thread != NULL; cur_thread = cur_thread->next()){
  31.      if(cur_thread == biased_thread){
  32.        thread_is_alive =true;
  33.        break;
  34.      }
  35.    }
  36.  }
  37.  // 如果偏向的线程已经不存活了
  38.  if(!thread_is_alive){
  39.    // 允许重偏向则将对象mark word设置为匿名偏向状态,否则设置为无锁状态
  40.    if(allow_rebias){
  41.      obj->set_mark(biased_prototype);
  42.    }else{
  43.      obj->set_mark(unbiased_prototype);
  44.    }
  45.    ...
  46.    returnBiasedLocking::BIAS_REVOKED;
  47.  }
  48.  // 线程还存活则遍历线程栈中所有的Lock Record
  49.  GrowableArray<MonitorInfo*>* cached_monitor_info = get_or_compute_monitor_info(biased_thread);
  50.  BasicLock* highest_lock = NULL;
  51.  for(int i =0; i < cached_monitor_info->length(); i++){
  52.    MonitorInfo* mon_info = cached_monitor_info->at(i);
  53.    // 如果能找到对应的Lock Record说明偏向的线程还在执行同步代码块中的代码
  54.    if(mon_info->owner()== obj){
  55.      ...
  56.      // 需要升级为轻量级锁,直接修改偏向线程栈中的Lock Record。为了处理锁重入的case,在这里将Lock Record的Displaced Mark Word设置为null,第一个Lock Record会在下面的代码中再处理
  57.      markOop mark = markOopDesc::encode((BasicLock*) NULL);
  58.      highest_lock = mon_info->lock();
  59.      highest_lock->set_displaced_header(mark);
  60.    }else{
  61.      ...
  62.    }
  63.  }
  64.  if(highest_lock != NULL){
  65.    // 修改第一个Lock Record为无锁状态,然后将obj的mark word设置为执行该Lock Record的指针
  66.    highest_lock->set_displaced_header(unbiased_prototype);
  67.    obj->release_set_mark(markOopDesc::encode(highest_lock));
  68.    ...
  69.  }else{
  70.    // 走到这里说明偏向线程已经不在同步块中了
  71.    ...
  72.    if(allow_rebias){
  73.       //设置为匿名偏向状态
  74.      obj->set_mark(biased_prototype);
  75.    }else{
  76.      // 将mark word设置为无锁状态
  77.      obj->set_mark(unbiased_prototype);
  78.    }
  79.  }
  80.  returnBiasedLocking::BIAS_REVOKED;
  81. }
需要注意下,当调用锁对象的Object#hash或System.identityHashCode()方法会导致该对象的偏向锁或轻量级锁升级。这是因为在Java中一个对象的hashcode是在调用这两个方法时才生成的,如果是无锁状态则存放在mark word中,如果是重量级锁则存放在对应的monitor中,而偏向锁是没有地方能存放该信息的,所以必须升级。
具体可以看这篇文章的hashcode()方法对偏向锁的影响小节(注意:该文中对于偏向锁的加锁描述有些错误),另外我也向该文章作者请教过一些问题,他很热心的回答了我,在此感谢一下!
言归正传,revoke_bias方法逻辑:
查看偏向的线程是否存活,如果已经不存活了,则直接撤销偏向锁。JVM维护了一个集合存放所有存活的线程,通过遍历该集合判断某个线程是否存活。
偏向的线程是否还在同步块中,如果不在了,则撤销偏向锁。我们回顾一下偏向锁的加锁流程:每次进入同步块(即执行monitorenter)的时候都会以从高往低的顺序在栈中找到第一个可用的Lock Record,将其obj字段指向锁对象。每次解锁(即执行monitorexit)的时候都会将最低的一个相关Lock Record移除掉。所以可以通过遍历线程栈中的Lock Record来判断线程是否还在同步块中。
将偏向线程所有相关Lock Record的Displaced Mark Word设置为null,然后将最高位的Lock Record的Displaced Mark Word 设置为无锁状态,最高位的Lock Record也就是第一次获得锁时的Lock Record(这里的第一次是指重入获取锁时的第一次),然后将对象头指向最高位的Lock Record,这里不需要用CAS指令,因为是在safepoint。 
执行完后,就升级成了轻量级锁。原偏向线程的所有Lock Record都已经变成轻量级锁的状态。这里如果看不明白,请回顾上篇文章的轻量级锁加锁过程。

偏向锁的释放

偏向锁的释放入口在bytecodeInterpreter.cpp#1923
  1. CASE(_monitorexit):{
  2.  oop lockee = STACK_OBJECT(-1);
  3.  CHECK_NULL(lockee);
  4.  // derefing's lockee ought to provoke implicit null check
  5.  // find our monitor slot
  6.  BasicObjectLock* limit = istate->monitor_base();
  7.  BasicObjectLock* most_recent =(BasicObjectLock*) istate->stack_base();
  8.  // 从低往高遍历栈的Lock Record
  9.  while(most_recent != limit ){
  10.    // 如果Lock Record关联的是该锁对象
  11.    if((most_recent)->obj()== lockee){
  12.      BasicLock*lock= most_recent->lock();
  13.      markOop header =lock->displaced_header();
  14.      // 释放Lock Record
  15.      most_recent->set_obj(NULL);
  16.      // 如果是偏向模式,仅仅释放Lock Record就好了。否则要走轻量级锁or重量级锁的释放流程
  17.      if(!lockee->mark()->has_bias_pattern()){
  18.        bool call_vm =UseHeavyMonitors;
  19.        // header!=NULL说明不是重入,则需要将Displaced Mark Word CAS到对象头的Mark Word
  20.        if(header != NULL || call_vm){
  21.          if(call_vm ||Atomic::cmpxchg_ptr(header, lockee->mark_addr(),lock)!=lock){
  22.            // CAS失败或者是重量级锁则会走到这里,先将obj还原,然后调用monitorexit方法
  23.            most_recent->set_obj(lockee);
  24.            CALL_VM(InterpreterRuntime::monitorexit(THREAD, most_recent), handle_exception);
  25.          }
  26.        }
  27.      }
  28.      //执行下一条命令
  29.      UPDATE_PC_AND_TOS_AND_CONTINUE(1,-1);
  30.    }
  31.    //处理下一条Lock Record
  32.    most_recent++;
  33.  }
  34.  // Need to throw illegal monitor state exception
  35.  CALL_VM(InterpreterRuntime::throw_illegal_monitor_state_exception(THREAD), handle_exception);
  36.  ShouldNotReachHere();
  37. }
上面的代码结合注释理解起来应该不难,偏向锁的释放很简单,只要将对应Lock Record释放就好了,而轻量级锁则需要将Displaced Mark Word替换到对象头的mark word中。如果CAS失败或者是重量级锁则进入到InterpreterRuntime::monitorexit方法中。该方法会在轻量级与重量级锁的文章中讲解。

批量重偏向和批量撤销

批量重偏向和批量撤销的背景可以看上篇文章,相关实现在BiasedLocking::revokeandrebias中:
  1. BiasedLocking::ConditionBiasedLocking::revoke_and_rebias(Handle obj,bool attempt_rebias, TRAPS){
  2.  ...
  3.  //code 1:重偏向的逻辑
  4.  HeuristicsResult heuristics = update_heuristics(obj(), attempt_rebias);
  5.  // 非重偏向的逻辑