对象的创建

1. 类加载检查： 虚拟机遇到一条new指令时，首先将去检查这个指令的参数是否能在常量池中定位到这个类的符号引用，并且检查这个符号引用代表的类是否已经被加载过、解析和初始化过。如果没有，那必须先执行相应的类加载过程。
2. 分配内存： 在类加载检查通过后，虚拟机将会非新生对象分配内存。对象所需的内存大小在类加载之后就可以确定了，为对象分配空间的过程等同于把一块确定大小的内存从Java堆中划分出来。分配方式有“指针碰撞”，“空闲列表”两种，选择哪种分配方式由Java堆是否规整决定，而Java堆是否规整又根据垃圾收集器是否带有压缩整理功能决定。

   1. 指针碰撞：假设Java堆内存是规整的，所有已分配的内存都在一边，未分配的都在另一边， 中间有指针指示器用来分隔二者，那么分配内存就是把指针指示器移动和对象大小相等的举例，这种方式成为“指针碰撞”（Serial、ParNew垃圾收集器，使用了标记-整理算法，系统采用的分配算法就为指针碰撞，简单又高效）

   2. 空闲列表：如果Java堆空间不是连续规整的，已分配的内存和空闲的内存混合在一起，那么就需要维护一个空闲列表，来记录哪些内存是可用的，在分配内存的时候从列表中找到一块足够大的空间给对象实例，并更新列表上的记录，这种方式称为“空闲列表”（CMS垃圾收集器，“理论上”就只能使用较为复杂的空闲列表，为什么是理论上呢？因为在CMS里为了更快的分配内存，设计了一个叫Linear Allocation Buffer的分配缓冲区，通过空闲列表拿到一大块分配缓冲区后，在它里面仍然可以使用指针碰撞方式来分配）

   3. 内存的分配方式：选择以上两种方式的哪一种，取决于Java内存是否规整，而Java内存是否规整取决于GC收集器的算法是“标记-清除”还是“标记-整理”，复制算法内存也是规整的

   4. 内存分配并发问题：在创建对象的时候有一个很重要的问题就是线程安全，因为在实际开发过程中，创建对象是很频繁的事情，作为虚拟机来说必须要保证线程安全才行，通常来讲，虚拟机采用两种方式来保证线程安全：

      1. CAS+失败重试： CAS是乐观锁的一种实现方式。所谓乐观锁就是，每次不加锁而是假设没有冲突而去完成某项操作， 如果因为冲突失败就重试，直到成功为止。虚拟机采用CAS配上失败重试的方式保证更新操作的原子性。
      2. TLAB： 把内存分配的动作按照线程划分在不同的空间中进行，即每个线程在Java堆中预先分配一小块内存成为本地线程缓存（Thread Local Allocation Buffer），JVM在给线程中的对象分配内存的时候，首先在TLAB分配，当对象大于TLAB中剩余内存或者TLAB中内存用尽时，再采用上述的CAS分配(可以使用-XX:+/-UseTLAB参数来开启或关闭TLAB)。

3.初始化零值：内存分配完成后，虚拟机需要将分配到的内存都初始化为零值（不包括对象头），这一步操作保证了对象的实例字段在Java代码中可以不赋初始值就可以使用，程序能访问到这些字段的数据类型对应的零值。
​

4.设置对象头：初始化零值完成后，虚拟机要对对象进行必要的设置，例如这个对象是哪个类的实例、如何才能找到类的元数据信息、对象的哈希码、对象的GC分代年龄等信息。这些信息存放在对象头中。另外，根据虚拟机当前运行状态 的不同，如是否启用偏向锁等，对象头会有不同的设置方式。
​

5.执行init方法：在上面的工作完成之后，从虚拟机的视角来看，一个新的对象已经产生了，但是从Java程序的视角来看，对象创建才刚开始，init方法还没有执行，所有的字段都还为零值。所以一般来说，执行new指令之后会紧接着执行init方法，把对象按照程序员的意愿进行初始化，这样一个真正可用的对象才算完全产生。

对象的内存布局

在HotSpot虚拟机中，对象在内存中的布局可以分为3块区域：对象头、实例数据和对齐填充。
​

内存分析小工具：

<!-- JOL依赖 -->
<dependency>
   <groupId>org.openjdk.jol</groupId>
   <artifactId>jol-core</artifactId>
   <version>0.9</version>
</dependency>

• 对象头包括两部分信息

  • 第一部分用于存储对象自身的运行时数据（官方称为Mark Word）：哈希码、GC分代年龄、锁状态标志等

    • 32位的HotSpot虚拟机中，如对象未被同步锁锁定的状态下，Mark Word的有25bit用于存储对象的hashCode，4个比特用于存储对象分代年龄，2个比特用于存储锁标志位，1个比特固定为0，在其他状态下锁标志位的状态如下：
      

      • 64位的HotSpot虚拟机中，Mark Word的存储情况如下:

  • 另一部分是类型指针，即对象指向它的类元数据的指针，虚拟机通过这个指针确定这个对象是哪个类的实例，如果对象是一个Java数组，那在对象头中还必须有一块用于记录数组长度的数据，因为虚拟机可以通过Java对象的元数据确定Java对象的大小，如果数组的长度不确定，将无法通过元数据信息推断出数组的大小。

• 实例数据部分是对象真正存储的有效信息， 也是程序中所定义的各种类型的字段内容，无论是从父类继承下来的，还是在子类中定义的字段都必须记录下来。这部分的存储顺序会受到虚拟机分配策略参数（-XX:FieldsAllocationStype参数）和字段在Java源码中定义的顺序影响。HotSpot默认的分配顺序为longs/doules、ints、shorts/chars，bytes/booleans、oops(Ordinary Objects Poninters，OOPs)，相同大小的字段总是被分配到一起存储，在满足这个条件的情况下， 父类中定义的变量会出现在子类之前。如果使用-XX:CompactFields=true(默认为true)，那子类中较小的变量也允许插入父类变量的空隙中，以省出一点点空间。
• 对齐填充部分不是天然存在的，也没有什么特别的含义，仅仅起占位作用。 因为Hotspot的自动内存管理系统要求对象起始地址必须是8字节的整数倍，换句话说就是对象的大小必须是8字节的整数倍。而对象头部分正好是8字节的倍数（1倍或者2倍），因此，当对象的实例数据部分没有对齐的时候，就需要通过对齐填充来补全，。

对象的访问定位

建立对象就是为了使用对象，我们的Java程序通过栈上的reference数据来操作堆上的具体对象。对象的访问方式由虚拟机实现而定，主流的访问方式有两种：

1. 句柄：如果使用的句柄的方式，那么虚拟机的堆内存中还会分出一块用作句柄池，Java虚拟机栈的本地变量表中reference中存储的就是对象的句柄地址，而句柄中包含了对象实例数据与类型数据各自的具体地址信息；
2. 直接指针（HotSpot使用的）：如果使用直接指针访问，那么Java堆对象的布局中就必须考虑如果放置访问类型数据的相关信息，而reference中存储的直接就是对象堆中的地址

这两种访问对象的方式各有优势。使用句柄来访问的最大的好处是reference中存储的是稳定的句柄地址，在对象移动的时候只改变句柄中的实例数据指针，而reference本身不需要修改。使用直接指针访问方式最大的好处就是访问速度快，它节省了一次指针定位的时间开销。
​

重点：String类和常量池

String创建对象的两种方式

String str1 = "abcd";
String str2 = new String("abcd");
System.out.println(str1==str2);//false

这两种创建方式是不同的，第一种是直接从常量池中把"abcd"的地址拿出来了；第二种通过new创建，会在堆中创建对象实例“abcd”。因此str1和str2中持有的分别是常量池的地址和堆的地址，false。

String类型的常量池比较特殊。使用方式：

• 直接使用双引号声明出来的String对象会直接存储在常量池中。
• 如果不使用双引号声明的String对象，可以使用String提供的intern()方法，String.intern()是一个Native方法，作用是：如果常量池中已经包含一个等于此String对象内容的字符串，则返回常量池中该字符串的引用；如果没有，则在常量池中创建于此String内容相同的字符串，并返回常量池中创建的字符串的引用。

String s1 = new String("计算机");
String s2 = s1.intern();//s2持有的是常量池中字符串的地址
String s3 = "计算机";
System.out.println(s2);//计算机
System.out.println(s1 == s2);//false，因为一个是堆内存中的String对象一个是常量池中的String对象，
System.out.println(s3 == s2);//true，因为两个都是常量池中的String对象

字符串拼接

String str1 = "str";
String str2 = "ing";

String str3 = "str" + "ing";//常量池中的对象
String str4 = str1 + str2; //在堆上创建的新的对象	  
String str5 = "string";//常量池中的对象
System.out.println(str3 == str4);//false
System.out.println(str3 == str5);//true
System.out.println(str4 == str5);//false

尽量避免使用拼接字符串，因为这样会创建多个对象，如果需要改变字符串的话，可以使用Stringbuilder或者Stringbuffer。

String s = new String("a")创建了几个对象

创建了两个对象。
验证：

String s1 = new String("abc");// 堆内存的地址值
String s2 = "abc";
System.out.println(s1 == s2);// 输出false,因为一个是堆内存，一个是常量池的内存，故两者是不同的。
System.out.println(s1.equals(s2));// 输出true

解释：先有字符串“abc”放入常量池，然后new了一个字符串“abc”放入Java堆（字符串常量“abc”在编译期就已经确定放入常量池，而Java堆上的“abc”是在运行期初始化阶段才确定）,然后Java虚拟机栈的s1指向Java堆上的“abc”。

String#intern

• JDK6中，intern方法会把首次遇到的字符串实例复制到永久代的字符串常量池中存储，返回的也是永久代里面这个字符串引用。
• JDK7中，intern方法实现就不需要再拷贝字符串的实例到永久代了，既然字符串常量池已经移到Java堆中，那只需要在常量池中记录一下首次出现实例的引用即可。

下面这段代码在JDK6、7中的执行结果不同

public class RuntimeConstantPoolOOM {
        public static void main(String[] args) {
            String str1 = new StringBuilder("计算机").append("软件").toString();
            System.out.println(str1.intern() == str1);
            String str2 = new StringBuilder("ja").append("va").toString();
            System.out.println(str2.intern() == str2);
        }
}

JDK6：false false   
    str1是虚拟机栈局部变量引用，str1.intern()持有的是"计算机软件"在永久代的引用。
    str2持有的是虚拟机栈局部变量引用,
JDK7：true  false   
    str

8种基本数据类型的包装类和常量池

• Java基本数据类型的包装类的大部分都实现了常量池技术，即Byte、Short、Long、Character、Boolean；这5种包装类默认创建了数值[-128,127]的相应类型的缓存数据，但是超出此范围仍然会去创建新的对象。
• 两种浮点数类型的包装类Float、Double并没有实现常量池技术。

Integer i1 = 33;
Integer i2 = 33;
System.out.println(i1 == i2);// 输出true
Integer i11 = 333;
Integer i22 = 333;
System.out.println(i11 == i22);// 输出false
Double i3 = 1.2;
Double i4 = 1.2;
System.out.println(i3 == i4);// 输出false

Integer缓存源代码：

/**
*此方法将始终缓存-128到127（包括端点）范围内的值，并可以缓存此范围之外的其他值。
*/
public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

应用场景：
1、Integer i1 = 40；Java在编译的时候会直接将代码封装成Integer i1 = Integer.valueOf(40)，从而使用常量池中的对象
2、Integer i1 =new Integer(40)；这种情况下会创建新的对象；

Integer i1 = 40;
Integer i2 = new Integer(40);
System.out.println(i1==i2);//输出false

Integer比较更丰富的一个例子:

Integer i1 = 40;
Integer i2 = 40;
Integer i3 = 0;
Integer i4 = new Integer(40);
Integer i5 = new Integer(40);
Integer i6 = new Integer(0);

System.out.println("i1=i2   " + (i1 == i2));
System.out.println("i1=i2+i3   " + (i1 == i2 + i3));
System.out.println("i1=i4   " + (i1 == i4));
System.out.println("i4=i5   " + (i4 == i5));
System.out.println("i4=i5+i6   " + (i4 == i5 + i6));   
System.out.println("40=i5+i6   " + (40 == i5 + i6));     

结果：

i1=i2   true
i1=i2+i3   true
i1=i4   false
i4=i5   false
i4=i5+i6   true
40=i5+i6   true

解释：
语句i4==i5 + i6，因为+这个操作符不适用于Integer对象，首先i5和i6进行自动拆箱操作，进行数值相加，即i4 == 40。然后Integer对象无法与数值进行直接比较，所以i4自动拆箱转为int值40，最终这条语句转为40 == 40进行数值比较。

来源：https://www.cnblogs.com/502819L/p/15431329.html