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中存储的则是对象的句柄地址。

对象实例数据：对象实例字段的数据
对象类型数据：对象的类型、父类实现的接口、方法等

image

4.2 直接指针

使用直接方式访问对象时，堆中对象存放的是对象的实例数据和指向对象类型数据的指针，reference则存储的是对象地址。

image

4.3 两种方式的对比

image

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 + 类型指针

https://www.jianshu.com/p/91e398d5d17c

对象创建问题

1. 请解释一下对象的创建过程？（半初始化）

2.对象在内存中的存储布局？（对象与数组的存储不同）

3.对象头具体包括什么？（markword classpointer）synchronized锁信息

对象头占用空间大小

指针压缩

会压缩的对象

启用指针压缩

4.对象怎么定位？（直接间接）

4.1 句柄

4.2 直接指针

4.3 两种方式的对比

2. 加问 DCL 与 volatile 问题？（指令重排）

6.对象怎么分配？（栈上-线程本地-Eden-Old）

7.Object o = new Object() 在内存中占用多少字节？

你可能感兴趣的:(对象创建问题)

对象创建问题

1. 请解释一下对象的创建过程？（半初始化）

2.对象在内存中的存储布局？（对象与数组的存储不同）

3.对象头具体包括什么？（markword classpointer）synchronized锁信息

对象头占用空间大小

指针压缩

会压缩的对象

启用指针压缩

4.对象怎么定位？（直接 间接）

4.1 句柄

4.2 直接指针

4.3 两种方式的对比

2. 加问 DCL 与 volatile 问题？（指令重排）

6.对象怎么分配？（栈上-线程本地-Eden-Old）

7.Object o = new Object() 在内存中占用多少字节？

你可能感兴趣的:(对象创建问题)

4.对象怎么定位？（直接间接）