java Object的hashCode方法的计算逻辑分析

1. 背景介绍

在为重写hashcode方法的时候，看到hashcode打印出的数据像是一个地址值，很是好奇。

加之最近在研读jvm源码，特此一探究竟，看看在hotspot中hashcode究竟是如何实现的。

2. 调用过程梳理

java的object代码

public native int hashcode();

通过官产jdk的object.class的源码, 发现hashcode被native修饰. 因此这个方法应该是在jvm中通过c/c++实现

jvm的hashcode相关代码

首先观察object.java对应的object.c代码

// 文件路径: jdk\src\share\native\java\lang\object.c
static jninativemethod methods[] = {
    {"hashcode",    "()i",                    (void *)&jvm_ihashcode}, // 这个方法就是我们想看的hashcode方法
    {"wait",        "(j)v",                   (void *)&jvm_monitorwait},
    {"notify",      "()v",                    (void *)&jvm_monitornotify},
    {"notifyall",   "()v",                    (void *)&jvm_monitornotifyall},
    {"clone",       "()ljava/lang/object;",   (void *)&jvm_clone},
};

进一步进入到jvm.h文件中, 这个文件中包含了很多java调用native方法的接口

// hotspot\src\share\vm\prims\jvm.h
/*
 * java.lang.object
 */
jniexport jint jnicall
jvm_ihashcode(jnienv *env, jobject obj); // 此时定了已hashcode方法的接口, 具体实现在jvm.cpp中

// hotspot\src\share\vm\prims\jvm.cpp
// java.lang.object ///
jvm_entry(jint, jvm_ihashcode(jnienv* env, jobject handle))
  jvmwrapper("jvm_ihashcode");
  // as implemented in the classic virtual machine; return 0 if object is null
  return handle == null ? 0 : objectsynchronizer::fasthashcode (thread, jnihandles::resolve_non_null(handle)) ; // 如果object为null, 就返回0; 否则就调用objectsynchronizer::fasthashcode
jvm_end

进入到objectsynchronizer::fasthashcode

// hotspot\src\share\vm\runtime\synchronizer.cpp
intptr_t objectsynchronizer::fasthashcode (thread * self, oop obj) {
// ....
 // 在fasthashcode方法中有一段关键代码:
 if (mark->is_neutral()) {
     hash = mark->hash();              // 首先通过对象的markword中取出hashcode
     if (hash) {                       // 如果取调到了, 就直接返回
       return hash;
     }
     hash = get_next_hash(self, obj);  // 如果markword中没有设置hashcode, 则调用get_next_hash生成hashcode
     temp = mark->copy_set_hash(hash); // 生成的hashcode设置到markword中
     // use (machine word version) atomic operation to install the hash
     test = (markoop) atomic::cmpxchg_ptr(temp, obj->mark_addr(), mark);
     if (test == mark) {
       return hash;
     }
 }
// ....
}

生成hashcode的方法get_next_hash, 可以支持通过参数配置不同的生成hashcode策略

// hotspot\src\share\vm\runtime\synchronizer.cpp
static inline intptr_t get_next_hash(thread * self, oop obj) {
  intptr_t value = 0 ;
  // 一共支持6中生成hashcode策略, 默认策略值是5
  if (hashcode == 0) {
  // 策略1: 直接通过随机数生成
     value = os::random() ;
  } else if (hashcode == 1) {
     // 策略2: 通过object地址和随机数运算生成
     intptr_t addrbits = cast_from_oop<intptr_t>(obj) >> 3 ;
     value = addrbits ^ (addrbits >> 5) ^ gvars.stwrandom ;
  } else if (hashcode == 2) {
  // 策略3: 永远返回1, 用于测试
     value = 1 ;            // for sensitivity testing
  } else if (hashcode == 3) {
  // 策略4: 返回一个全局递增的序列数
     value = ++gvars.hcsequence ;
  } else if (hashcode == 4) {
  // 策略5: 直接采用object的地址值
     value = cast_from_oop<intptr_t>(obj) ;
  } else {
     // 策略6: 通过在每个线程中的四个变量: _hashstatex, _hashstatey, _hashstatez, _hashstatew
     // 组合运算出hashcode值, 根据计算结果同步修改这个四个值
     unsigned t = self->_hashstatex ;
     t ^= (t << 11) ;
     self->_hashstatex = self->_hashstatey ;
     self->_hashstatey = self->_hashstatez ;
     self->_hashstatez = self->_hashstatew ;
     unsigned v = self->_hashstatew ;
     v = (v ^ (v >> 19)) ^ (t ^ (t >> 8)) ;
     self->_hashstatew = v ;
     value = v ;
  }
  value &= markoopdesc::hash_mask; // 通过hashcode的mask获得最终的hashcode值
  if (value == 0) value = 0xbad ;
  assert (value != markoopdesc::no_hash, "invariant") ;
  tevent (hashcode: generate) ;
  return value;
}

3. 关于hashcode值的大小

前面以及提交到hashcode生成后, 是存储在markword中, 我们在深入看一下这个markword

// hotspot\src\share\vm\oops\markoop.hpp
class markoopdesc: public oopdesc {
 private:
  // conversion
  uintptr_t value() const { return (uintptr_t) this; }
 public:
  // constants
  enum { age_bits                 = 4,
         lock_bits                = 2,
         biased_lock_bits         = 1,
         max_hash_bits            = bitsperword - age_bits - lock_bits - biased_lock_bits,
         hash_bits                = max_hash_bits > 31 ? 31 : max_hash_bits, // 通过这个定义可知, hashcode可占用31位bit. 在32位jvm中,  hashcode占用25位
         cms_bits                 = lp64_only(1) not_lp64(0),
         epoch_bits               = 2
  };
  
}

4. 验证

package test;
/***
 * 可以通过系列参数指定hashcode生成策略
 * -xx:hashcode=2
 */
public class testhashcode {
    public static void main(string[] args) {
        object obj1 = new object();
        object obj2 = new object();
        system.out.println(obj1.hashcode());
        system.out.println(obj2.hashcode());
    }
}

通过-xx:hashcode=2这种形式, 可以验证上述的5中hashcode生成策略

5. 总结

在64位jvm中, hashcode最大占用31个bit; 32位jvm中, hashcode最大占用25个bit

hashcode一共有六种生成策略

序号	hashcode策略值	描述
1	0	直接通过随机数生成
2	1	通过object地址和随机数运算生成
3	2	永远返回1, 用于测试
4	3	返回一个全局递增的序列数
5	4	直接采用object的地址值
6	其他	通过在每个线程中的四个变量: _hashstatex, _hashstatey, _hashstatez, _hashstatew 组合运算出hashcode值, 根据计算结果后修改这个四个值

默认策略采用策略6, 在globals.hpp文件中定义

  product(intx, hashcode, 5,                                                \
          "(unstable) select hashcode generation algorithm")  

以上为个人经验，希望能给大家一个参考，也希望大家多多支持。