1. 请解释一下对象的创建过程？（半初始化）
2.对象在内存中的存储布局？（对象与数组的存储不同）
对象与数组的存储不同
markword：锁状态、分代年龄、hashcode、偏向线程ID、偏向时间戳等信息。在32位系统占4字节，在64位系统中占8字节。
类型指针class pointer：对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例， 32位系统占4字节，在64位系统中占8字节。
实例数据Instance data：是对象存储的真正的有效信息，存储着自身定义的和从父类继承下来的实例字段。字段的存储熟悉怒会受虚拟机的分配策略和字段在java源码中
数组长度length：如果是数组对象，还有一个保存数组长度的空间，占4个字节；
对齐padding，由于虚拟机要求对象起始地址必须是8字节的整数倍，填充数据不是必须存在的，仅仅是为了字节对齐。
3.对象头具体包括什么？（markword classpointer）synchronized锁信息
markword与类型指针都是属于对象头
一个刚刚 new 出来的对象，如果开始上锁 （synchronized），它的一个升级过程是：
new -> 偏向锁 -> 自旋锁（无锁、lock-free、轻量级锁） -> 重量级锁。这些信息都记录在 markword 里面。
对象实际数据
对象实际数据包括了对象的所有成员变量，其大小由各个成员变量的大小决定，比如：byte和boolean是1个字节，short和char是2个字节，int和float是4个字节，long和double是8个字节，reference是4个字节（64位系统中是8个字节）。
| Primitive Type | Memory Required(bytes) |
|---|---|
| boolean | 1 |
| byte | 1 |
| short | 2 |
| char | 2 |
| int | 4 |
| float | 4 |
| long | 8 |
| double | 8 |
对于reference类型来说，在32位系统上占用4bytes, 在64位系统上占用8bytes。
对象头占用空间大小
这里说明一下32位系统和64位系统中对象所占用内存空间的大小：
| 数据 | 32位操作系统 | 64位操作系统 | 64位开启指针压缩 |
|---|---|---|---|
| MarkWord | 4 | 8 | - |
| Class Pointer | 4 | 8 | 4 |
指针压缩
64位JVM消耗的内存会比32位的要多大约1.5倍，这是因为对象指针在64位JVM下有更宽的寻址。对于那些将要从32位平台移植到64位的应用来说，平白无辜多了1/2的内存占用，这是开发者不愿意看到的。
从JDK 1.6 update14开始，64位的JVM正式支持了 -XX:+UseCompressedOops 这个可以压缩指针，起到节约内存占用的新参数。
会压缩的对象
- 每个Class的属性指针（静态成员变量）；
- 每个对象的属性指针；
- 普通对象数组的每个元素指针。
` 当然，压缩也不是所有的指针都会压缩，对一些特殊类型的指针，JVM是不会优化的，例如指向PermGen（永久代）的Class对象指针、本地变量、堆栈元素、入参、返回值和NULL指针不会被压缩。
启用指针压缩
在Java程序启动时增加JVM参数：-XX:+UseCompressedOops来启用。
注意：32位HotSpot VM是不支持UseCompressedOops参数的，只有64位HotSpot VM才支持
本文中使用的是JDK 1.8，默认该参数就是开启的。
4.对象怎么定位？（直接 间接）
两种方式：句柄方式 、 直接指针
当在堆内存中创建对象之后，java程序需要refrence数据来操作对象。由于reference类型在java虚拟机规范中只规定了指向对象的引用,并没有规定这个引用以如何的方式去定位、访问堆中的对象具体位置.
其中Reference是java中的引用类，它主要是对普通对象进行包装，从而在JVM在垃圾回收时，按照引用类型的不同，在回收时采用不同的逻辑。
4.1 句柄
使用句柄方式访问兑对象时，需要在堆中划出一部分内存作为句柄池，句柄池中存放各个对象的句柄，句柄包含了:
对象实例数据的指针
对象类型数据的指针
而reference中存储的则是对象的句柄地址。
对象实例数据：对象实例字段的数据
对象类型数据：对象的类型、父类实现的接口、方法等
4.2 直接指针
使用直接方式访问对象时，堆中对象存放的是对象的实例数据和指向对象类型数据的指针，reference则存储的是对象地址。
4.3 两种方式的对比
2. 加问 DCL 与 volatile 问题？（指令重排）
为了理解什么是 DCL （双检锁/双重校验锁（DCL，即 double-checked-locking）），我们先回顾一下 单例模式（Singleton Pattern）。
- 单例类只能有一个实例。
- 单例类必须直接创建直接的唯一实例。
- 单例类必须给所有其他对象提供这一实例。
参考代码1
/**
* 饿汉模式
* 类加载到内存后，就实例化一个单例。JVM保证线程安全
* 简单使用，推荐使用
* 唯一缺点：不管用到与否，类装载时就完成实例化
* Class.forName("")
* (话说你不用的，你装载它干啥)
*/
public class Mgr01 {
// 创建 Mgr01 的一个对象
private static final Mgr01 INSTANCE = new Mgr01();
//让构造函数为 private，这样该类就不会被实例化
private Mgr01(){
}
// 获取唯一可用的对象
public static Mgr01 getInstance(){
return INSTANCE;
}
public void m() {
System.out.println("m");
}
public static void main(String[] args) {
Mgr01 m1 = Mgr01.getInstance();
Mgr01 m2 = Mgr01.getInstance();
System.out.println(m1 == m2);
}
参考代码1，这种写法有人会说 INSTANCE还没用就直接 new 出来了，假如说创建的过程特别浪费资源，能不能够等我想用的时候再初始化出来。
参考代码2:
/**
* 虽然达到了按需初始化的目的，但却带来了线程不安全
*/
public class Mgr02 {
private static Mgr02 INSTANCE;
private Mgr02() {
}
public static Mgr02 getInstance() {
if (INSTANCE == null) {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Mgr02();
}
return INSTANCE;
}
public void m() {
System.out.println("m");
}
public static void main(String[] args) {
for (int i = 0; i< 100; i++) {
new Thread(() ->
System.out.println(Mgr02.getInstance().hashCode())
).start();
}
}
}
还有人接着说，参考代码2，线程不安全，多线程访问情况下有可能会 new 出多个对象出来。自然而然我们想到加锁来解决.
参考代码3
/**
* 增加synchronized，线程安全
*/
public class Mgr03 {
private static Mgr03 INSTANCE;
private Mgr03() {
}
public static synchronized Mgr03 getInstance() {
if (INSTANCE == null) {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Mgr03();
}
return INSTANCE;
}
public void m() {
System.out.println("m");
}
public static void main(String[] args) {
for (int i = 0; i< 100; i++) {
new Thread(() ->
System.out.println(Mgr03.getInstance().hashCode())
).start();
}
}
}
可是有的人还会说，你上来二话不说整个方法全上锁，锁的粒度是不是太粗了。于是我们换个写法。
参考代码4
public class Mgr04 {
private static Mgr04 INSTANCE;
private Mgr04() {
}
public static Mgr04 getInstance() {
// 业务代码
if (INSTANCE == null) {
// 妄图通过减少同步代码块的方式提高效率，然后不可行
synchronized (Mgr04.class) {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Mgr04();
}
}
return INSTANCE;
}
public void m() {
System.out.println("m");
}
public static void main(String[] args) {
for (int i = 0; i< 100; i++) {
new Thread(() ->
System.out.println(Mgr04.getInstance().hashCode())
).start();
}
}
}
这个版本在多线程访问情况下，是线程不安全的。于是诞生了 “DCL” 写法。
参考代码5
public class Mgr05 {
private static volatile Mgr05 INSTANCE;
private Mgr05() {
}
public static Mgr05 getInstance() {
// 业务代码
if (INSTANCE == null) { // Double Check Lock
// 双重检查
synchronized (Mgr05.class) {
if (INSTANCE == null) {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Mgr05();
}
}
}
return INSTANCE;
}
public void m() {
System.out.println("m");
}
public static void main(String[] args) {
for (int i = 0; i< 100; i++) {
new Thread(() ->
System.out.println(Mgr05.getInstance().hashCode())
).start();
}
}
}
volatile 主要有两个作用：
线程可见性
禁止指令重排序（上下都要加内存屏障）
那么到底需不需加 volatile 关键字，我们来分析下：
当第一个线程来的时候，判断它为空，开始对它进行初始化（new）。当 new 一半的时候，只拿到了默认值，还没获取初始化值。
这个时候下面两条指令有可能会发生 指令重排序 ，这时候就会先建立关联，再调用构造方法赋予初始值。目前 t 就执行了 半初始化 的这个状态对象
当 t 指向半初始化状态对象的时候，正好这个时候第二个线程来了，当前 t指向了半初始化状态的对象， 肯定不为空。那就直接用了，那就用半初始化状态的这个对象，就会发生不可预知的错误。
6.对象怎么分配？（栈上-线程本地-Eden-Old）
7.Object o = new Object() 在内存中占用多少字节？
对象的内存以字节为单位，且必须是8的倍数，它由3部分组成：
对象头 + 实例数据 + 对齐内存
对象头= Mark word + 类型指针
