Unsafe类getBoolean方法解析

以Unsafe类的下列方法为例子

public native boolean getBoolean(Object var1, long var2);

java本地方法以jni调用实现(jni如何调用先不做介绍)，按照jni中java方法和c方法的对应关系，那么在c中名称应该为

jboolean, Unsafe_GetBoolean(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)

实际为

jboolean, Unsafe_Get##Boolean(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)

定义在宏中，使用了##连接操作符，内容为

UNSAFE_ENTRY(jboolean, Unsafe_Get##Boolean(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)) \
  UnsafeWrapper("Unsafe_Get"#Boolean); \
  GET_FIELD(obj, offset, jboolean, v); \
  return v; \
UNSAFE_END \

原则是调用

GET_FIELD(obj, offset, jboolean, v)

查看其源码

#define GET_FIELD(obj, offset, type_name, v) \
  oop p = JNIHandles::resolve(obj); \
  type_name v = *(type_name*)index_oop_from_field_offset_long(p, offset)

再看看index_oop_from_field_offset_long方法

inline void* index_oop_from_field_offset_long(oop p, jlong field_offset) {
  jlong byte_offset = field_offset_to_byte_offset(field_offset);
#ifdef ASSERT
  if (p != NULL) {
    assert(byte_offset >= 0 && byte_offset <= (jlong)MAX_OBJECT_SIZE, "sane offset");
    if (byte_offset == (jint)byte_offset) {
      void* ptr_plus_disp = (address)p + byte_offset;
      assert((void*)p->obj_field_addr<oop>((jint)byte_offset) == ptr_plus_disp,
             "raw [ptr+disp] must be consistent with oop::field_base");
    }
    jlong p_size = HeapWordSize * (jlong)(p->size());
    assert(byte_offset < p_size, err_msg("Unsafe access: offset " INT64_FORMAT " > object's size " INT64_FORMAT, byte_offset, p_size));
  }
#endif
  if (sizeof(char*) == sizeof(jint))    // (this constant folds!)
    return (address)p + (jint) byte_offset;
  else
    return (address)p +        byte_offset;
}

就是传入对象的地址，并告诉返回类型的偏移量，然后c++通过指针及偏移返回对应的地址初始位置，再根据类型(确定指针类型)强转成对应类型的值返回，地址+偏移=对应数据的地址

下面确认下java传入的fieldOffset是啥值

package com.jinrong.zaxiang.refect;

import java.lang.reflect.Field;

/**
 * @author wocan23
 * @create 2019/9/24 下午5:56
 */
public class RefectTest {

    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
        User user = new User();
        user.setAge(2);
        user.setName("zss");
        user.setFlagStudent(true);

        Class aClass = user.getClass();
        Field flagStudentField = aClass.getDeclaredField("flagStudent");
        flagStudentField.setAccessible(true);
        boolean aBoolean = flagStudentField.getBoolean(user);


        Field nameField = aClass.getDeclaredField("name");
        nameField.setAccessible(true);
        Object o = nameField.get(user);

        Field ageField = aClass.getDeclaredField("age");
        ageField.setAccessible(true);
        Object o1 = ageField.getInt(user);

    }
}
class User{
    private int age; // offset 12
    private String name; // offset 20
    private boolean flagStudent; // offset 16

    public boolean isFlagStudent() {
        return flagStudent;
    }

    public void setFlagStudent(boolean flagStudent) {
        this.flagStudent = flagStudent;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

跟断点发现offset为16，再看下name和age得offset为多少20和12 调换下顺序，偏移量仍旧未变

再增加一个变量

class User{
    private String name; // offset 20
    private int age; // offset 12
    private boolean flagStudent; // offset 16
    private boolean flagMale; // offset 17

发现只是新增得变了,其实际字节码中顺序和声明顺序不一样

另外成员是从12开始，64位Java虚拟机引入了压缩指针概念（对应虚拟机选项 -XX:+UseCompressedOops，默认开启），将堆中原本64位的Java对象指针压缩成32位的。
这样一来，对象头的类型指针也会被压缩成32位，使得对象头大小从16字节降低为12字节