Java如何对一个对象进行创建

Java如何对一个对象进行创建

前言：

不知道大家是怎么针对java学习的！我了解的很多人都是通过网上别人的博客、书籍来学习的；也有人会看些jdk的源代码结合官方文档来学习。

我发现很少有同学会通过编译jvm去学习java更底层的知识，往往是通过网上博客，道听途说，然后认为自己就学会了。也有很少一部分同学会结合oracle的文档跟java源代码（包括jvm）去学习，只是我发现我周围并没有很多这样的人。可能是c++的门槛吧！

本身我也只是大学的时候学了些c++，没有好好学，目前也都忘光了，但是如果只是理解逻辑的话，其实也是可以理解的。为了更深入的理解java，在windows下编译过jvm，看过一些底层代码。遗憾，自己记性差点，当时记得，现在又忘了。用以记录一下，也为了分享一些更好的学习方式。

Java对象的创建

我们都知道，java程序员创建对象的时候就是无非在java的类文件中，new ojbect即可。那么创建之后，java是怎样运行的呢？

周志明书上这么写的

步骤：

一、jvm接收到new指令，在常量池中检查是否存在实例化类的符号引用；

二、无，则进行类加载；有，则检查符号引用对应的该类是否已经被初始化；

三、为对象分配内存（两种：指针碰撞、空闲指针，具体看收集器），类加载时已确定大小；

四、针对分配的内存，除头信息外，进行初始化，也就是清空置零；

五、将对象头（看classFile）填充元数据、hash值等，此时完成jvm的操作；

六、java继续执行<init>方法，实例化对象，完成java的实例化。

空口无凭呗，别人说道的再好，如果不动手实践，或者看一下，还是填鸭式的，没成就感不说，还不一定能理解的了！

图片2.png

这个文件bytecodeInterpreter.cpp。是关于字节码的解释执行器，也就是很多的字节码指令，都是从这里开始检测运行的，可以很容易搜索到putfield等java的字节码指令！我们如果要了解对象的创建过程，只需要根据字节码指令找到对应位置即可。

查询“Java字节码指令表”，可知，是new指令，所以，我们可以在，该文件中搜索new：

图片3.png

可能光标位置不对吧，CASE到的是 _newarray指令，查询到指令表，表示是创建一个原始类型的数组，根据注释也可以看得出来“ /* Allocate memory for a new java object. */

”，类似，new是为了申请内存的，接着搜索：

图片4.png 图片5.png

ClassFile接下来就可以解读了，可以结合oracle关于classfile的官方文档：
PS：本来是直接从word贴过来的文档，但是到markdown之后，就不是vs的格式了，不慎好看，将就看吧
//如果是创建指令

CASE(_new): {

//从字节码流中获取索引值

        u2 index = Bytes::get_Java_u2(pc+1);

//得到常量池的数据结构

        constantPoolOop constants = istate->method()->constants();

/**

* tag_at:看过classfile就知道这是从常量池中取符号值

* 判断常量池中该类是不是已经被解释过了

* unresolved_klass：所以使用合理的命名规范可以很容易读代码的

**/

        if (!constants->tag_at(index).is_unresolved_klass()) {

          // 这里的注释的意思是确保初始化的跟要new的是同一个对象

          // Make sure klass is initialized and doesn't have a finalizer

          oop entry = constants->slot_at(index).get_oop();

assert(entry->is_klass(), "Should be resolved klass");

          klassOop k_entry = (klassOop) entry;

assert(k_entry->klass_part()->oop_is_instance(), "Should be instanceKlass");

          instanceKlass* ik = (instanceKlass*) k_entry->klass_part();

//判断是否进行过初始化

          if ( ik->is_initialized() && ik->can_be_fastpath_allocated() ) {

//对象长度

            size_t obj_size = ik->size_helper();

            oop result = NULL;

            // 如果tlab没有被预先置零，则会先置为零。TLAB：本地线程缓冲区

            // If the TLAB isn't pre-zeroed then we'll have to do it

            bool need_zero = !ZeroTLAB;

//如果为true，则需要再本地线程缓冲区分配对象

            if (UseTLAB) {

              result = (oop) THREAD->tlab().allocate(obj_size);

            }

  //如果对象结果为NULL，则表示需要将所有字段置为0

            if (result == NULL) {

need_zero = true;

//尝试在共享eden区域分配

              // Try allocate in shared eden

        retry:

 //应该就是获取当前指针位置

              HeapWord* compare_to = *Universe::heap()->top_addr();

 //需要移动指针的位置，当前位置 + 对象大小

              HeapWord* new_top = compare_to + obj_size;

 //如果新的高度（指针位置），小于等于堆的结束地址，则继续执行

              if (new_top <= *Universe::heap()->end_addr()) {

   //结合书上，此cas指令，并发情况下，如果失败了，则goto到 retry不断重试

                if (Atomic::cmpxchg_ptr(new_top, Universe::heap()->top_addr(), compare_to) != compare_to) {

                  goto retry;

                }

   //也就是满足上述条件，则直接分配了

                result = (oop) compare_to;

              }

            }

   //如果对象结果不为NULL

            if (result != NULL) {

 // （）如果不为0，需要置为0）初始化对象

              // Initialize object (if nonzero size and need) and then the header

              if (need_zero ) {

  //这几个应该是置零操作

HeapWord* to_zero = (HeapWord*) result + sizeof(oopDesc) / oopSize;

obj_size -= sizeof(oopDesc) / oopSize;

   //分配内存？

                if (obj_size > 0 ) {

                  memset(to_zero, 0, obj_size * HeapWordSize);

                }

              }

 //偏向锁决定了设置对象头（MarkWord）的方式：研究的不是特别深，大致意思应该是偏向锁在没有多线程竞争下，减少cas操作，偏向锁只cas threadId一次，减少开销，所以分配内存应该也有些不同吧

              if (UseBiasedLocking) {

                result->set_mark(ik->prototype_header());

} else {

                result->set_mark(markOopDesc::prototype());

              }

 //这个应该就是传说中的对象补齐？

              result->set_klass_gap(0);

              result->set_klass(k_entry);

 //很明显的命名：设置该对象入栈操作

              SET_STACK_OBJECT(result, 0);

              UPDATE_PC_AND_TOS_AND_CONTINUE(3, 1);

            }

          }

        }

        // Slow case allocation

        CALL_VM(InterpreterRuntime::_new(THREAD, METHOD->constants(), index),

                handle_exception);

        SET_STACK_OBJECT(THREAD->vm_result(), 0);

        THREAD->set_vm_result(NULL);

        UPDATE_PC_AND_TOS_AND_CONTINUE(3, 1);

      }

Java的对象头信息有：对象的hash值、分代年龄（标记）、指向轻量级锁指针、指向重量级锁指针、Gc标记、偏向线程id、偏向时间戳、对象分代年龄。PS：发现了，这块也得出一篇文章去分析markWord.cpp。

注意内容：

内存分配两种方式：

一、指针碰撞，规整堆内存空间情况下，直接移动指针位置来分配；

二、空闲列表，不规整对内存空间情况下，维护这么一个列表，用于记录内存可用性。

这两种分配方式，根据收集器不同，采用不同的方式：如CMS收集的时候，由于基于标记交换算法，所以采用了空闲列表；一般其他的收集器的话就用指针碰撞。

CAS创建对象：

其实可以看出来在retry的时候，也就是创建对象不是线程安全的，会出现给一个对象分配内存的指针还没有移动的时候，高并发情况下，另一对象又来操作对象的创建，这时候就会出现问题了。

JVM有两种解决的方式：

一种就是Atomic::cmpxchg_ptr，通过CAS，不断重试来保证原子性；

另一种，就是判断偏向锁情况下，根据不同线程的“tlab：本地线程分配缓冲区”，分配不同的区域。（那么上边的，根据偏向锁使用不同的分配方式也就理解是什么意思了）

如此这些操作完成之后，jvm的对象创建分配过程即可完成。

而在java层面，如果看过classfile的话，就能看的出来，调用java初始化<init>方法，完成java层面的初始化。