image.png

1.场景：匿名偏向

指第一个线程进入 可偏向但还没有偏向的101锁 的场景

2.场景：重入

重入是指线程t1 还没有释放锁，然后t1又来获取锁。
image.png

重入后的状态

image.pngimage.png

3.场景：重新加锁

重新加锁(再次偏向)是指线程t1 释放偏向锁后，再次访问这个偏向锁。
第二次偏向的性能要比第一次高，因为第一次还需要有一个CAS设置线程id的过程。
image.png

bytecodeInterpreter.cpp

  1.    /* monitorenter and monitorexit for locking/unlocking an object */
  2.     CASE(_monitorenter): {
  3.         //为这个锁 创建一个空的Lock Record
  4.         oop lockee = STACK_OBJECT(-1);
  5.         CHECK_NULL(lockee);
  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.           else if (most_recent->obj() == lockee) break;
  13.           most_recent++;
  14.         }
  15.         if (entry != NULL) {
  16.           //把当前锁对象的markword存储到1ock Record当中的displaced header
  17.           entry->set_obj(lockee);
  18.           int success = false;
  19.           uintptr_t epoch_mask_in_place = (uintptr_t)markOopDesc::epoch_mask_in_place;
  21.           markOop mark = lockee->mark();
  22.           intptr_t hash = (intptr_t) markOopDesc::no_hash;
  23.           // 是否开启偏向锁
  24.           if (mark->has_bias_pattern()) {
  25.             uintptr_t thread_ident;
  26.             uintptr_t anticipated_bias_locking_value;
  27.              //获取线程id
  28.             thread_ident = (uintptr_t)istate->thread();
  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);
  34.             if  (anticipated_bias_locking_value == 0) {
  35.               // 值为0 表示已经是偏向自己
  36.               if (PrintBiasedLockingStatistics) {
  37.                 (* BiasedLocking::biased_lock_entry_count_addr())++;
  38.               }
  39.               success = true;
  40.             }
  41.              // 偏向禁用
  42.             else if ((anticipated_bias_locking_value & markOopDesc::biased_lock_mask_in_place) != 0) {
  43.               // try revoke bias 禁用：撤销偏向达到40次   从类当中拿到的对象头
  44.               markOop header = lockee->klass()->prototype_header();
  45.               if (hash != markOopDesc::no_hash) {
  46.                 header = header->copy_set_hash(hash);
  47.               }
  48.               if (lockee->cas_set_mark(header, mark) == mark) {
  49.                 if (PrintBiasedLockingStatistics)
  50.                   (*BiasedLocking::revoked_lock_entry_count_addr())++;
  51.               }
  52.             }
  53.               //poch_mask_in_place 判断是否过期
  54.             else if ((anticipated_bias_locking_value & epoch_mask_in_place) !=0) {
  55.               // try rebias 重新偏向
  56.               // 创建一个偏向当前线程的markword
  57.               markOop new_header = (markOop) ( (intptr_t) lockee->klass()->prototype_header() | thread_ident);
  59.               if (hash != markOopDesc::no_hash) {
  60.                 new_header = new_header->copy_set_hash(hash);
  61.               }
  62.                //将该锁设置为偏向当前线程
  63.               if (lockee->cas_set_mark(new_header, mark) == mark) {
  64.                 if (PrintBiasedLockingStatistics)
  65.                   (* BiasedLocking::rebiased_lock_entry_count_addr())++;
  66.               }
  67.               else {
  68.                 //CAS失败
  69.                 CALL_VM(InterpreterRuntime::monitorenter(THREAD, entry), handle_exception);
  70.               }
  71.               success = true;
  72.             }
  73.             else {
  74.               // 匿名偏向 或者 偏向了别人 这两种情况
  75.               // try to bias towards thread in case object is anonymously biased
  76.               // 在内存中 创建一个匿名可偏向 header 101
  77.               markOop header = (markOop) ((uintptr_t) mark & ((uintptr_t)markOopDesc::biased_lock_mask_in_place |
  78.                                                               (uintptr_t)markOopDesc::age_mask_in_place |
  79.                                                               epoch_mask_in_place));
  80.               if (hash != markOopDesc::no_hash) {
  81.                 header = header->copy_set_hash(hash);
  82.               }
  83.               // 又创建一个偏向自己的new_header  thread_id + 101
  84.               markOop new_header = (markOop) ((uintptr_t) header | thread_ident);
  85.               // debugging hint
  86.               DEBUG_ONLY(entry->lock()->set_displaced_header((markOop) (uintptr_t) 0xdeaddead);)
  87.               // CAS 如果是匿名偏向，就改为偏向自己，将new_header 设置到锁的markword当中去
  88.               if (lockee->cas_set_mark(new_header, header) == header) {
  89.                 if (PrintBiasedLockingStatistics)
  90.                   (* BiasedLocking::anonymously_biased_lock_entry_count_addr())++;
  91.               }
  92.               else {
  93.                 //CAS失败
  94.                 CALL_VM(InterpreterRuntime::monitorenter(THREAD, entry), handle_exception);
  95.               }
  96.               success = true;
  97.             }
  98.           }
  100.           // 当前偏向的线程不是自己
  101.           // traditional lightweight locking
  102.           if (!success) {
  103.              //首先产生一个无锁的markword
  104.             markOop displaced = lockee->mark()->set_unlocked();
  105.             entry->lock()->set_displaced_header(displaced);
  106.             bool call_vm = UseHeavyMonitors;
  107.              // CAS将这个无锁的markword替换到锁记录中，如果成功则轻量级锁加锁成功
  108.             if (call_vm || lockee->cas_set_mark((markOop)entry, displaced) != displaced) {
  109.                //进入这个if表示轻量级锁加锁失败
  110.                     //是否是重入的场景
  111.               if (!call_vm && THREAD->is_lock_owned((address) displaced->clear_lock_bits())) {
  112.                 entry->lock()->set_displaced_header(NULL);
  113.               } else {
  114.                   //重量级锁
  115.                 CALL_VM(InterpreterRuntime::monitorenter(THREAD, entry), handle_exception);
  116.               }
  117.             }
  118.           }
  119.            //执行CPU的下一条指令
  120.           UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);
  122.         } else {
  123.           istate->set_msg(more_monitors);
  124.           UPDATE_PC_AND_RETURN(0); // Re-execute
  125.         }
  126.       }
  128.       CASE(_monitorexit): {
  129.         oop lockee = STACK_OBJECT(-1);
  130.         CHECK_NULL(lockee);
  131.         // derefing's lockee ought to provoke implicit null check
  132.         // find our monitor slot
  133.         BasicObjectLock* limit = istate->monitor_base();
  134.         BasicObjectLock* most_recent = (BasicObjectLock*) istate->stack_base();
  135.         while (most_recent != limit ) {
  136.           if ((most_recent)->obj() == lockee) {
  137.             BasicLock* lock = most_recent->lock();
  138.             markOop header = lock->displaced_header();
  139.             most_recent->set_obj(NULL);
  140.             if (!lockee->mark()->has_bias_pattern()) {
  141.               bool call_vm = UseHeavyMonitors;
  142.               // If it isn't recursive we either must swap old header or call the runtime
  143.               if (header != NULL || call_vm) {
  144.                 markOop old_header = markOopDesc::encode(lock);
  145.                 if (call_vm || lockee->cas_set_mark(header, old_header) != old_header) {
  146.                   // restore object for the slow case
  147.                   most_recent->set_obj(lockee);
  148.                   CALL_VM(InterpreterRuntime::monitorexit(THREAD, most_recent), handle_exception);
  149.                 }
  150.               }
  151.             }
  152.             UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);
  153.           }
  154.           most_recent++;
  155.         }
  156.         // Need to throw illegal monitor state exception
  157.         CALL_VM(InterpreterRuntime::throw_illegal_monitor_state_exception(THREAD), handle_exception);
  158.         ShouldNotReachHere();
  159.       }

批量重偏向

偏向撤销

等待全局安全点，删除锁记录等等的过程。 撤销很消耗性能。

批量重偏向-轻量级锁降级为偏向锁

当一个线程创建了大量对象并执行了初始的同步操作，后来另一个线程也来将这些对象作为锁对象进行操作，会导偏向锁重偏向的操作。JVM 认为如果对同一个类的对象进行了20次偏向撤销，就会产生批量重偏向。
此时锁 由 轻量级锁 =》偏向锁。

批量撤销

批量撤销-禁用偏向锁

JVM 认为如果对同一个类的对象进行了40次单个撤销，JVM会认为代码设计有问题，对所有该类的对象进行批量撤销，并且从此对这个类禁用偏向锁，修改类class文件中的markword为001。
在超过40次本应该为可偏向状态偏向锁101的新对象，在经历过批量重偏向和批量撤销后直接在实例化后转为无锁001。
image.png

  • 批量重偏向和批量撤销是针对类的优化，和对象无关。
  • 偏向锁重偏向一次之后不可再次重偏向。
  • 当某个类已经触发批量撤销机制后，JVM会默认当前类产生了严重的问题，剥夺了该类的新实例对象使用偏向锁的权利

偏向过期

image.png
当一个类被加载到元空间后，这个类的类信息会成为创建这个类的对象的模板，这个epoch的值就是存在于类信息中的模板值，默认为01。
当发生批量重偏向时，就会对元空间中这个类的epoch值 +1。
当一个线程访问偏向锁，发现epoch值不等于初始值时，就认为这个偏向锁过期了，可以直接把该锁设置为偏向自己。