从 markword 到 synchronized 深入解析

JVM_ENTRY(jint, JVM_IHashCode(JNIEnv* env, jobject handle))
  // as implemented in the classic virtual machine; return 0 if object is null
  return handle == nullptr ? 0 :
         checked_cast<jint>(ObjectSynchronizer::FastHashCode (THREAD, JNIHandles::resolve_non_null(handle)));
JVM_EN

// Register native methods of Object
void java_lang_Object::register_natives(TRAPS) {
  InstanceKlass* obj = vmClasses::Object_klass();
  Method::register_native(obj, vmSymbols::hashCode_name(), vmSymbols::void_int_signature(), 
  (address) &JVM_IHashCode, CHECK);
}

intptr_t ObjectSynchronizer::FastHashCode(Thread* current, oop obj) {
    //omit
    hash = mark.hash();
      if (hash != 0) return hash; // if it has a hash, just return it
    hash = get_next_hash(current, obj);  // get a new hash
    temp = mark.copy_set_hash(hash);     // merge the hash into header
                                           // try to install the hash
    test = obj->cas_set_mark(temp, mark);
    if (test == mark) return hash; // if the hash was installed, return it
}

if (dest_attr.is_young()) {
    if (age < markWord::max_age) {
        obj->incr_age();
    }
}

void oopDesc::incr_age() {
  markWord m = mark();
  if (m.has_displaced_mark_helper()) { //与 synchronized 有关
    m.set_displaced_mark_helper(m.displaced_mark_helper().incr_age());
  } else {
    set_mark(m.incr_age());
  }
}

//Compact object headers
Header (compact):
64                    42                             11   7   3  0
 [CCCCCCCCCCCCCCCCCCCCCCHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHVVVVAAAASTT]
 (Compressed Class Pointer)       (Hash Code)         /(GC Age)^(Tag)
                              (Valhalla-reserved bits) (Self Forwarded Tag)

//src/hotspot/cpu/aarch64/frame_aarch64.hpp

// Layout of asm interpreter frame:
//    [expression stack      ] * <- sp
//    [monitors[0]           ]   \
//     ...                        | monitor block size = k
//    [monitors[k-1]         ]   /
//    [frame initial esp     ] ( == &monitors[0], initially here)       initial_sp_offset
//    [byte code index/pointr]                   = bcx()                bcx_offset
//    [pointer to locals     ]                   = locals()             locals_offset
//    [constant pool cache   ]                   = cache()              cache_offset
//    [klass of method       ]                   = mirror()             mirror_offset
//    [extended SP           ]                                          extended_sp offset
//    [methodData            ]                   = mdp()                mdx_offset
//    [Method                ]                   = method()             method_offset
//    [last esp              ]                   = last_sp()            last_sp_offset
//    [sender's SP           ]                     (sender_sp)          sender_sp_offset
//    [old frame pointer     ]   <- fp           = link()
//    [return pc             ]
//    [last sp               ]
//    [oop temp              ]                     (only for native calls)
//    [padding               ]                     (to preserve machine SP alignment)
//    [locals and parameters ]
//                               <- sender sp
// ------------------------------ Asm interpreter ----------------------------------------

class BasicObjectLock {
  BasicLock _lock;// the lock, must be double word aligned
  oop       _obj; // object holds the lock;
}

void frame::oops_interpreted_do(OopClosure* f, const RegisterMap* map, bool query_oop_map_cache) const {
  for (
    BasicObjectLock* current = interpreter_frame_monitor_end();
    current < interpreter_frame_monitor_begin();
    current = next_monitor_in_interpreter_frame(current)
  ) {
    current->oops_do(f);
  }
}

class BasicObjectLock {
   // GC support
  void oops_do(OopClosure* f) { f->do_oop(&_obj); }
}

void frame::oops_interpreted_do(OopClosure* f, const RegisterMap* map, bool query_oop_map_cache) const {
  Thread *thread = Thread::current();
  methodHandle m (thread, interpreter_frame_method());
  int count = 0;
  for (
    BasicObjectLock* current = interpreter_frame_monitor_end();
    current < interpreter_frame_monitor_begin();
    current = next_monitor_in_interpreter_frame(current)
  ) {
     count++;
    current->oops_do(f);
  }
  const char* method_name = m()->name()->as_C_string();
  if (strcmp(method_name, "testCountMonitorInMethod") == 0) {
    tty->print_cr("Current method name: %s, basicObjectLock: %d", method_name, count);
  }
}

void BytecodeInterpreter::run(interpreterState istate) {
  //omit
        CASE(_monitorenter): {
        oop lockee = STACK_OBJECT(-1);
        BasicObjectLock* limit = istate->monitor_base();
        BasicObjectLock* most_recent = (BasicObjectLock*) istate->stack_base();
        BasicObjectLock* entry = nullptr;
        while (most_recent != limit ) {
          if (most_recent->obj() == nullptr) entry = most_recent;
          else if (most_recent->obj() == lockee) break;
          most_recent++;
        }
        //omit
    }
    //omit
}

intptr_t*             _stack_base;    // base of expression stack
// Layout of asm interpreter frame:
//    [expression stack      ] * <- sp
//    [monitors[0]           ]   \
//     ...                        | monitor block size = k
//    [monitors[k-1]         ]   /
//    [frame initial esp     ] ( == &monitors[0], initially here)       initial_sp_offset

entry->set_obj(lockee);
if (LockingMode == LM_LEGACY) {
      // Traditional fast locking.
      markWord displaced = lockee->mark().set_unlocked();
      entry->lock()->set_displaced_header(displaced);
      success = true;
      if (lockee->cas_set_mark(markWord::from_pointer(entry), displaced) != displaced) {
        // Is it simple recursive case?
        if (THREAD->is_lock_owned((address) displaced.clear_lock_bits().to_pointer())) {
          entry->lock()->set_displaced_header(markWord::from_pointer(nullptr));
        } else {
          success = false;
        }
      }
      if (success) {
        THREAD->inc_held_monitor_count();
      }
}

// A BasicObjectLock associates a specific Java object with a BasicLock.
// It is currently embedded in an interpreter frame.

// Because some machines have alignment restrictions on the control stack,
// the actual space allocated by the interpreter may include padding words
// after the end of the BasicObjectLock.  Also, in order to guarantee
// alignment of the embedded BasicLock objects on such machines, we
// put the embedded BasicLock at the beginning of the struct.
class BasicObjectLock

product(int, LockingMode, LM_LIGHTWEIGHT,                                 \
        "(Deprecated) Select locking mode: "                              \
        "0: (Deprecated) monitors only (LM_MONITOR), "                    \
        "1: (Deprecated) monitors & legacy stack-locking (LM_LEGACY), "   \
        "2: monitors & new lightweight locking (LM_LIGHTWEIGHT, default)") \
        range(0, 2)                                                       \

//->InterpreterRuntime::monitorenter
inline void ObjectSynchronizer::enter(Handle obj, BasicLock* lock, JavaThread* current) {
  if (LockingMode == LM_LIGHTWEIGHT) {
    LightweightSynchronizer::enter(obj, lock, current);
  } else {
    enter_legacy(obj, lock, current);
  }
}

class JavaThread: public Thread {
  LockStack _lock_stack;
}
class LockStack {
  static const int CAPACITY = 8;
  uint32_t _top;
  const uintptr_t _bad_oop_sentinel = badOopVal;
  oop _base[CAPACITY]
}

inline bool LightweightSynchronizer::fast_lock_try_enter(oop obj, LockStack& lock_stack, JavaThread* current) {
  markWord mark = obj->mark();
  while (mark.is_unlocked()) {
    ensure_lock_stack_space(current);
    // Try to swing into 'fast-locked' state.
    markWord locked_mark = mark.set_fast_locked();
    markWord old_mark = mark;
    mark = obj->cas_set_mark(locked_mark, old_mark);
    if (old_mark == mark) {
      lock_stack.push(obj);
      return true;
    } }
  return false;
}

void LightweightSynchronizer::ensure_lock_stack_space(JavaThread* current) {
  LockStack& lock_stack = current->lock_stack();
  // Make room on lock_stack
  if (lock_stack.is_full()) {
    // Inflate contended objects
    LockStackInflateContendedLocks().inflate(current);
    if (lock_stack.is_full()) {
      // Inflate the oldest object
      inflate_fast_locked_object(lock_stack.bottom(), ObjectSynchronizer::inflate_cause_vm_internal, current, current);
    }
  }
}

bool LightweightSynchronizer::fast_lock_spin_enter(oop obj, LockStack& lock_stack, JavaThread* current, bool observed_deflation) {
  // LightweightFastLockingSpins = 13
  const int log_spin_limit = os::is_MP() ? LightweightFastLockingSpins : 1;
  const int log_min_safepoint_check_interval = 10;

  markWord mark = obj->mark();
  const auto should_spin = [&]() {
    if (!mark.has_monitor()) {
      return true;
    } else if (observed_deflation) {/*observed_deflation is false*/ }
    return false;
  };
  // Always attempt to lock once even when safepoint synchronizing.
  bool should_process = false;
  for (int i = 0; should_spin() && !should_process && i < log_spin_limit; i++) {
    // Spin with exponential backoff.
    const int total_spin_count = 1 << i;
    const int inner_spin_count = MIN2(1 << log_min_safepoint_check_interval, total_spin_count);
    const int outer_spin_count = total_spin_count / inner_spin_count;
    for (int outer = 0; outer < outer_spin_count; outer++) {
      should_process = SafepointMechanism::should_process(current);
      if (should_process) { break; }
      for (int inner = 1; inner < inner_spin_count; inner++) { SpinPause(); }
    }
    if (fast_lock_try_enter(obj, lock_stack, current)) return true;
  }
  return false;
}

inline bool LockStack::try_recursive_enter(oop o) {

  int end = to_index(_top);
  if (end == 0 || _base[end - 1] != o) {
    return false;
  }
  _base[end] = o;
  _top += oopSize;
  return true;
}