oop-klass
klass
在JVM中，Klass是用来描述一个类的元数据的，里面包括了类的修饰符、类名、父类、类加载器等，简单来说就是描述一个Java类的元数据的数据结构。
class Klass : public Metadata {
friend class VMStructs;
protected:
// note: put frequently-used fields together at start of klass structure
// for better cache behavior (may not make much of a difference but sure won't hurt)
enum { _primary_super_limit = 8 };
// The "layout helper" is a combined descriptor of object layout.
// For klasses which are neither instance nor array, the value is zero.
//
// For instances, layout helper is a positive number, the instance size.
// This size is already passed through align_object_size and scaled to bytes.
// The low order bit is set if instances of this class cannot be
// allocated using the fastpath.
//
// For arrays, layout helper is a negative number, containing four
// distinct bytes, as follows:
// MSB:[tag, hsz, ebt, log2(esz)]:LSB
// where:
// tag is 0x80 if the elements are oops, 0xC0 if non-oops
// hsz is array header size in bytes (i.e., offset of first element)
// ebt is the BasicType of the elements
// esz is the element size in bytes
// This packed word is arranged so as to be quickly unpacked by the
// various fast paths that use the various subfields.
//
// The esz bits can be used directly by a SLL instruction, without masking.
//
// Note that the array-kind tag looks like 0x00 for instance klasses,
// since their length in bytes is always less than 24Mb.
//
// Final note: This comes first, immediately after C++ vtable,
// because it is frequently queried.
jint _layout_helper;
// The fields _super_check_offset, _secondary_super_cache, _secondary_supers
// and _primary_supers all help make fast subtype checks. See big discussion
// in doc/server_compiler/checktype.txt
//
// Where to look to observe a supertype (it is &_secondary_super_cache for
// secondary supers, else is &_primary_supers[depth()].
juint _super_check_offset;
// Class name. Instance classes: java/lang/String, etc. Array classes: [I,
// [Ljava/lang/String;, etc. Set to zero for all other kinds of classes.
Symbol* _name;
// Cache of last observed secondary supertype
Klass* _secondary_super_cache;
// Array of all secondary supertypes
Array<Klass*>* _secondary_supers;
// Ordered list of all primary supertypes
Klass* _primary_supers[_primary_super_limit];
// java/lang/Class instance mirroring this class
oop _java_mirror;
// Superclass
Klass* _super;
// First subclass (NULL if none); _subklass->next_sibling() is next one
Klass* _subklass;
// Sibling link (or NULL); links all subklasses of a klass
Klass* _next_sibling;
// All klasses loaded by a class loader are chained through these links
Klass* _next_link;
// The VM's representation of the ClassLoader used to load this class.
// Provide access the corresponding instance java.lang.ClassLoader.
ClassLoaderData* _class_loader_data;
jint _modifier_flags; // Processed access flags, for use by Class.getModifiers.
AccessFlags _access_flags; // Access flags. The class/interface distinction is stored here.
// Biased locking implementation and statistics
// (the 64-bit chunk goes first, to avoid some fragmentation)
jlong _last_biased_lock_bulk_revocation_time;
markOop _prototype_header; // Used when biased locking is both enabled and disabled for this type
jint _biased_lock_revocation_count;
TRACE_DEFINE_KLASS_TRACE_ID;
// Remembered sets support for the oops in the klasses.
jbyte _modified_oops; // Card Table Equivalent (YC/CMS support)
jbyte _accumulated_modified_oops; // Mod Union Equivalent (CMS support)
这里就是Klass包含的Java类的大部分元数据
oop
oop全称Ordinary Object Pointer，翻译过来就是普通对象指针，在JVM中，oop对应的类是oopDesc，每new一个Java实例就会创建一个oopDesc，oopDesc包含了两部分信息，_mark和_metadata，markword是用来存储对象的锁信息和分代年龄用的，_metadata就是指向klass的一个指针，通过指针可以拿到这个类的元数据。
class oopDesc {
friend class VMStructs;
private:
volatile markOop _mark;
union _metadata {
Klass* _klass;
narrowKlass _compressed_klass;
} _metadata;
为什么要用oop-klass模型
One reason for the oop/klass dichotomy in the implementation is that we don't want a C++ vtbl pointer in every object. Thus, normal oops don't have any virtual functions. Instead, they forward all "virtual" functions to their klass, which does have a vtbl and does the C++ dispatch depending on the object's actual type. (See oop.inline.hpp for some of the forwarding code.)
上面这段话是在Klass.cpp的注释中的，大概意思是在JVM中，设计者不想让每个对象都保存一份虚函数表，(ps:虚函数表主是要一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其容真实反应实际的函数。这样，在有虚函数的类的实例中这个表被分配在了这个实例的内存中，所以，当我们用父类的指针来操作一个子类的时候，这张虚函数表就显得由为重要了，它就像一个地图一样，指明了实际所应该调用的函数)，所以JVM就把对象一分为二，用klass和oop来表示，klass用来存储对象的方法和其他元数据信息，oop用来存储对象的实例数据，也就是Java的对象头信息。
Java对象在内存中的布局
图中的Mark Word就是oop中的_mark，指向Class的指针就是oop中的Klass，这两部分合起来就叫Java对象头。对象的Body部分就是Java实例的实例变量，也就是我们在Java类中定义的成员变量。对齐字节简单理解就是，在JVM中，Java对象的大小都必须是8bytes的整数倍，所以当上述的实例变量的字节不是8的整数倍时，就要使用对齐字节来填充。
java.lang.Class与Klass
// java/lang/Class instance mirroring this class
oop _java_mirror;
上面的这行代码是Klass中定义的，注释的意思就是_java_mirror这个实例表示java.lang.Class，在JVM加载类的时候，会创建一个oop的实例来表示Class实例，_java_mirror的Klass指针会指向真正的Klass，在调用Class.newInstance创建Java实例的时候，_java_mirror会找到真正的Klass完成实例的创建。至于为什么要用_java_mirror这个变量来表示java.lang.Class而不直接用Klass，根据我的理解，因为JVM用的是Klass-oop模型，所以对于java.lang.Class的实例来说也会分为Klass和oop，oop表示的是Class的对象头信息，klass包含了Class方法等元数据信息。
所以在Java中，访问一个对象的实例的过程就如下图所示：
Java对象在内存中的存储
这里的内存讨论是在JVM内存层面，不深入到操作系统内存层面。
一个Java对象在内存中的数据包含三个部分，对象头、实例数据、对齐填充。
对象头上面已经说过了，包括了Mark Work和对象指针；
实例数据就是Java类的成员变量，包括父类的成员变量；
对齐填充没有存储数据，起占位符的作用，因为在HotSpot VM中要求对象的起始地址是8的倍数，所以如果对象头加实例数据的大小不是8的倍数就要利用对齐填充来补充到8的倍数。
实验一
我的机器64位的，默认开启指针压缩的。
工具是JOL：
<dependency>
<groupId>org.openjdk.jol</groupId>
<artifactId>jol-core</artifactId>
<version>0.9</version>
</dependency>
可以看到objectHeader就是对象头，里面包括了Mark Work和Klass(对象指针)，一共占了12字节，因为Mark Work占了8bytes，Klass压缩后占了4bytes，偏移量是0。成员变量a和b分别占了四个字节，a的偏移量是12，b的偏移量是16。object header + a + b的size就是20，不是8的整数倍，所以要加上对齐填充4bytes成为24bytes。
实验二
TestObject1继承Super后排在对象头后面的就是Super的成员变量，接下来才是TestObject1的成员变量，Super中有一个成员变量是Object类型，也是占了4bytes，存储的并不是Object的数据，而是Object的引用地址。
