一.搭建jdk源码环境

  1. 1.1找到jdk安装目录

jdk源码环境及调试 - 图1

  1. 1.2.获取jdk下src安装包

jdk源码环境及调试 - 图2

  1. 1.3将src复制到其他目录并解压，然后在ideal中配置原源码路径

jdk源码环境及调试 - 图3

  1. 1.4去除源码保护

jdk源码环境及调试 - 图4

  1. 1.5debug调试源码

jdk源码环境及调试 - 图5
jdk源码环境及调试 - 图6

二.Object类

2.1 Oject是如何织入的

  1. jdk1.6以及之前Object通过继承的方式织入
  2. jdk1.6之后是通过虚拟机织入的
  3. 我们使用ideal能够直接调用Object类中的方法是因为里面的插件

jdk源码环境及调试 - 图7

2.2 Obect中native方法是如果调用的

  1. native 是调用底层c c++语言的方法，源码包地址
  2. 链接：https://pan.baidu.com/s/1rW6UYVAO4LKcdQtZxCUxVQ 
  3. 提取码：1111
  1. 在加载静态代码块的时候，会通过registerNatives（）加载，通过method函数对java和c++方法做映射

jdk源码环境及调试 - 图8

jdk源码环境及调试 - 图9
jdk源码环境及调试 - 图10

2.3 hashcode

  1. 查看java对象的内存地址需要导入jdk工具包，调用方法VM.current().addressOf(java对象)
  1. <!--jdk工具 能够查看对象的内存地址-->
  2.         <dependency>
  3.             <groupId>org.openjdk.jol</groupId>
  4.             <artifactId>jol-core</artifactId>
  5.             <version>0.9</version>
  6.         </dependency>
  1. Obejct中hashcode底层是通过xor算法得出的随机数，以下是hashcode的计算方法 默认为5
  2. product(intx, hashCode, 5,                                                \
  3.           "(Unstable) select hashCode generation algorithm")                \
  4. OpenJDK8 默认hashCode的计算方法是通过和当前线程有关的一个随机数+三个确定值，运用Marsaglia's xorshift scheme随机数算法得到的一个随机数。和对象内存地址无关
  6. 具体算法解释可以看下这俩篇大佬的文章
  7. https://urlify.cn/URzeua
  8. https://www.jianshu.com/p/be943b4958f4
  1. static inline intptr_t get_next_hash(Thread * Self, oop obj) {
  2.   intptr_t value = 0 ;
  3.   if (hashCode == 0) {
  4.      // This form uses an unguarded global Park-Miller RNG,
  5.      // so it's possible for two threads to race and generate the same RNG.
  6.      // On MP system we'll have lots of RW access to a global, so the
  7.      // mechanism induces lots of coherency traffic.
  8.      value = os::random() ;
  9.   } else
  10.   if (hashCode == 1) {
  11.      // This variation has the property of being stable (idempotent)
  12.      // between STW operations.  This can be useful in some of the 1-0
  13.      // synchronization schemes.
  14.      intptr_t addrBits = intptr_t(obj) >> 3 ;
  15.      value = addrBits ^ (addrBits >> 5) ^ GVars.stwRandom ;
  16.   } else
  17.   if (hashCode == 2) {
  18.      value = 1 ;            // for sensitivity testing
  19.   } else
  20.   if (hashCode == 3) {
  21.      value = ++GVars.hcSequence ;
  22.   } else
  23.   if (hashCode == 4) {
  24.      value = intptr_t(obj) ;
  25.   } else {
  26.      // Marsaglia's xor-shift scheme with thread-specific state
  27.      // This is probably the best overall implementation -- we'll
  28.      // likely make this the default in future releases.
  29.      unsigned t = Self->_hashStateX ;
  30.      t ^= (t << 11) ;
  31.      Self->_hashStateX = Self->_hashStateY ;
  32.      Self->_hashStateY = Self->_hashStateZ ;
  33.      Self->_hashStateZ = Self->_hashStateW ;
  34.      unsigned v = Self->_hashStateW ;
  35.      v = (v ^ (v >> 19)) ^ (t ^ (t >> 8)) ;
  36.      Self->_hashStateW = v ;
  37.      value = v ;
  38.   }
  40.   value &= markOopDesc::hash_mask;
  41.   if (value == 0) value = 0xBAD ;
  42.   assert (value != markOopDesc::no_hash, "invariant") ;
  43.   TEVENT (hashCode: GENERATE) ;
  44.   return value;
  45. }
  1. hashcode并不是内存地址，串池中的内存地址和堆中的内存地址并不一样，当使用intern()方法是当串池中有当前字符串会将串池中对象地址返回回来，如果没有会将堆中对象地址放入串池并返回

jdk源码环境及调试 - 图11

2.4 为什么要同时重写hashcode和equals方法

  1. 个人理解：对象的hashcode是有可能重复的，当前重复的时候我们需要去根据字段的属性判断两个对象是否相等 这个时候需要对对象各个属性的值进行判断，就需要重新equals方法（object的equals方法是比较的内存地址）