CASE(_monitorenter): {
        // 拿到鎖對(duì)象
        oop lockee = STACK_OBJECT(-1);
        // derefing's lockee ought to provoke implicit null check
        CHECK_NULL(lockee);
        // find a free monitor or one already allocated for this object
        // if we find a matching object then we need a new monitor
        // since this is recursive enter
        // 從當(dāng)前線程棧中找到一個(gè)沒有被使用的BasicObjectLock
        // 作用：用來記錄鎖狀態(tài)
        BasicObjectLock* limit = istate->monitor_base();
        BasicObjectLock* most_recent = (BasicObjectLock*) istate->stack_base();
        BasicObjectLock* entry = NULL;
        while (most_recent != limit ) {
          if (most_recent->obj() == NULL) entry = most_recent;
          else if (most_recent->obj() == lockee) break;
          most_recent++;
        }
        if (entry != NULL) {
          // 搶坑，為什么這里不需要CAS，因?yàn)閷儆诰€程棧（線程變量），線程安全。
          entry->set_obj(lockee);
          int success = false;
          // 得到epoch的掩碼。
          uintptr_t epoch_mask_in_place = (uintptr_t)markOopDesc::epoch_mask_in_place;
          // 得到當(dāng)前鎖對(duì)象的對(duì)象頭。
          markOop mark = lockee->mark();
          intptr_t hash = (intptr_t) markOopDesc::no_hash;
          // implies UseBiasedLocking
          // 當(dāng)前是偏向鎖模式，可以用JVM參數(shù)UseBiasedLocking控制
          if (mark->has_bias_pattern()) {
            uintptr_t thread_ident;
            uintptr_t anticipated_bias_locking_value;
            thread_ident = (uintptr_t)istate->thread();
            // lockee->klass()->prototype_header() 是否拿到對(duì)象的類模板的頭部信息。
            // lockee->klass()->prototype_header() | thread_ident) 是類模板頭部信息組合上線程id
            // mark 是當(dāng)前鎖對(duì)象的頭部信息。
            // markOopDesc::age_mask_in_place 是當(dāng)前對(duì)象的年齡信息。
            // 所以與年齡無關(guān)
            // 所以拿鎖對(duì)象的原型對(duì)象的對(duì)象頭控制
            // lockee->klass()->prototype_header() | thread_ident) ^ (uintptr_t)mark 如果為0 代表當(dāng)前對(duì)象頭偏向鎖偏向了當(dāng)前線程
            anticipated_bias_locking_value =
              (((uintptr_t)lockee->klass()->prototype_header() | thread_ident) ^ (uintptr_t)mark) &
              ~((uintptr_t) markOopDesc::age_mask_in_place);
            // 等于0代表當(dāng)前鎖對(duì)象頭部和類模板頭部一樣。
            // 所以這是一次偏向鎖的命中。
            if  (anticipated_bias_locking_value == 0) {
              // already biased towards this thread, nothing to do
              if (PrintBiasedLockingStatistics) {
                (* BiasedLocking::biased_lock_entry_count_addr())++;
              }
              success = true;
            }
            // 當(dāng)前對(duì)象頭已經(jīng)膨脹成輕量級(jí)或者重量級(jí)鎖了。也即非偏向鎖。
            else if ((anticipated_bias_locking_value & markOopDesc::biased_lock_mask_in_place) != 0) {
              // try revoke bias
              // 嘗試撤銷偏向鎖
              markOop header = lockee->klass()->prototype_header();
              if (hash != markOopDesc::no_hash) {
                header = header->copy_set_hash(hash);
              }
              // CAS嘗試取消偏向
              if (Atomic::cmpxchg_ptr(header, lockee->mark_addr(), mark) == mark) {
                if (PrintBiasedLockingStatistics)
                  (*BiasedLocking::revoked_lock_entry_count_addr())++;
              }
            }
            // 來到這里可能表示當(dāng)前偏向于其他線程。
            // 而epoch發(fā)生了變動(dòng)，表示批量撤銷偏向鎖了。
            // 當(dāng)前線程可以嘗試爭搶一次偏向鎖，沒有成功就去鎖升級(jí)
            else if ((anticipated_bias_locking_value & epoch_mask_in_place) !=0) {
              // try rebias
              // 嘗試重偏向
              markOop new_header = (markOop) ( (intptr_t) lockee->klass()->prototype_header() | thread_ident);
              if (hash != markOopDesc::no_hash) {
                new_header = new_header->copy_set_hash(hash);
              }
              // CAS競爭，重偏向。
              if (Atomic::cmpxchg_ptr((void*)new_header, lockee->mark_addr(), mark) == mark) {
                if (PrintBiasedLockingStatistics)
                  (* BiasedLocking::rebiased_lock_entry_count_addr())++;
              }
              // CAS失敗，鎖升級(jí)
              else {
                  // 鎖升級(jí)邏輯
                CALL_VM(InterpreterRuntime::monitorenter(THREAD, entry), handle_exception);
              }
              success = true;
            }
            // 來到這里表示，當(dāng)前是匿名偏向鎖（也即暫時(shí)還沒有線程占用）
            // 或者是已經(jīng)偏向了某個(gè)線程，所以這里CAS嘗試一次
            else {
              // try to bias towards thread in case object is anonymously biased
              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));
              if (hash != markOopDesc::no_hash) {
                header = header->copy_set_hash(hash);
              }
              markOop new_header = (markOop) ((uintptr_t) header | thread_ident);
              // debugging hint
              DEBUG_ONLY(entry->lock()->set_displaced_header((markOop) (uintptr_t) 0xdeaddead);)
              // 如果是匿名偏向，這個(gè)CAS就有可能成功
              // 如果是已經(jīng)偏向其他線程，這個(gè)CAS不能成功，直接往鎖升級(jí)走
              if (Atomic::cmpxchg_ptr((void*)new_header, lockee->mark_addr(), header) == header) {
                if (PrintBiasedLockingStatistics)
                  (* BiasedLocking::anonymously_biased_lock_entry_count_addr())++;
              }
              // cas失敗
              else {
                  // 鎖升級(jí)邏輯
                CALL_VM(InterpreterRuntime::monitorenter(THREAD, entry), handle_exception);
              }
              success = true;
            }
          }
          // traditional lightweight locking
          // case1:如果當(dāng)前已經(jīng)鎖升級(jí)了
          // case2:如果當(dāng)前不支持偏向鎖
          if (!success) {
            markOop displaced = lockee->mark()->set_unlocked();
            entry->lock()->set_displaced_header(displaced);
            bool call_vm = UseHeavyMonitors;
            // UseHeavyMonitors是JVM參數(shù)，是否直接開啟重量級(jí)鎖
            // 如果不直接開啟，就CAS競爭輕量級(jí)鎖，競爭成功就直接返回
            if (call_vm || Atomic::cmpxchg_ptr(entry, lockee->mark_addr(), displaced) != displaced) {
              // Is it simple recursive case?
              // CAS失敗可能是鎖重入，如果不是鎖重入，那么就是競爭失敗要往鎖升級(jí)邏輯走了。
              if (!call_vm && THREAD->is_lock_owned((address) displaced->clear_lock_bits())) {
                  // 輕量級(jí)鎖的鎖重入
                entry->lock()->set_displaced_header(NULL);
              } else {
                  // 鎖升級(jí)邏輯
                CALL_VM(InterpreterRuntime::monitorenter(THREAD, entry), handle_exception);
              }
            }
          }
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);
        } else {
          istate->set_msg(more_monitors);
          UPDATE_PC_AND_RETURN(0); // Re-execute
        }
      }