Java内存布局

最新推荐文章于 2024-07-01 09:20:45 发布
最新推荐文章于 2024-07-01 09:20:45 发布
阅读量223 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lizc_lizc/article/details/108544995
版权

Java对象内存布局

在HotSpot虚拟机里，对象在堆内存中的存储布局可以划分为三个部分：

  • 对象头（Header）

  • 实例数据（Instance Data）

  • 对齐填充（Padding）

对象头：HotSpot虚拟机对象的对象头包括三部分信息。

  1. 第一部分是用来存储对象自身的运行时数据。如哈希码（HashCode）、分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等，这部分数据的长度在32bit和64bit的虚拟机（未开启压缩指针）中分别为32bit和64bit，官方称它为“Mark Word”。

    Java对象头里的Mark Word里默认存储对象的HashCode、分代年龄和锁标记位。以32bit的HotSpot虚拟机为例，如对象处于无锁状态下，各状态如下所示

在运行期间，Mark Word里存储的数据会随着锁标志位的变化而变化。Mark Word可能变化为存储以下4种数据

在64位虚拟机下，Mark Word是64bit大小的，其存储结构如下所示

  1. 第二部分是类型指针。通过这个指针来确定该对象是哪个类的实例。jdk1.8默认开启指针压缩后为4字节，当在JVM参数中关闭指针压缩（-XX:-UseCompressedOops）后，长度为8字节。
  2. 第三部分存储数组长度，只有对象为数组时才会存在。

可以看出，在64位虚拟机中，一个对象头的长度最小为8字节（MarkWord）+ 4字节（类型指针，默认开启的指针压缩）= 12个字节。而对象的长度必须为8字节的整数倍，那么就必须还有4字节的填充数据，那么一个对象就最少有16个字节的长度。

实例数据：对象真正存储的有效信息

对齐填充：由于HotSpot虚拟机的自动内存管理系统要求对象起始地址必须是8字节的整数倍，换句话说就是
任何对象的大小都必须是8字节的整数倍。对象头部分已经被精心设计成正好是8字节的倍数（1倍或者
2倍），因此，如果对象实例数据部分没有对齐的话，就需要通过对齐填充来补全。

查看内存布局

通过工具可以分析下对象的具体结构，依赖地址如下

<dependency>
    <groupId>org.openjdk.jol</groupId>
    <artifactId>jol-core</artifactId>
    <version>0.12</version>
</dependency>

编写代码

public class T {
    public static void main(String[] args) {
        T obj = new T();
        System.out.println(obj);
        System.out.println(ClassLayout.parseInstance(obj).toPrintable());
    }
}

控制台打印结果

com.example.demo.test.T@7106e68e
com.example.demo.test.T object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           01 8e e6 06 (00000001 10001110 11100110 00000110) (115772929)
      4     4        (object header)                           71 00 00 00 (01110001 00000000 00000000 00000000) (113)
      8     4        (object header)                           05 c1 00 20 (00000101 11000001 00000000 00100000) (536920325)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

从打印结果可以看出该对象一共占有16字节(对象头占8字节+类型指针占4字节+填充数据占4字节)。
由于jdk1.8默认开启指针压缩，所以类型指针只占4字节，通过虚拟机参数(-XX:-UseCompressedOops)关闭指针压缩再看下效果

com.example.demo.test.T@7106e68e
com.example.demo.test.T object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           01 8e e6 06 (00000001 10001110 11100110 00000110) (115772929)
      4     4        (object header)                           71 00 00 00 (01110001 00000000 00000000 00000000) (113)
      8     4        (object header)                           28 30 c5 17 (00101000 00110000 11000101 00010111) (398798888)
     12     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
Instance size: 16 bytes
Space losses: 0 bytes internal + 0 bytes external = 0 bytes total

这个时候对象的结构只剩下对象头信息了，MarkWord还是8个字节，而类型指针变成了8字节。

为了看到实例数据，我们需要在对象中定义一些变量，修改代码如下

public class T {
    public int m1 = 123;
    public long m2 = 456L;
    public String m3 = "789";
    public static void main(String[] args) {
        T obj = new T();
        System.out.println(obj);
        System.out.println(ClassLayout.parseInstance(obj).toPrintable());
    }
}

控制台打印结果

com.example.demo.test.T@7106e68e
com.example.demo.test.T object internals:
 OFFSET  SIZE               TYPE DESCRIPTION                               VALUE
      0     4                    (object header)                           01 8e e6 06 (00000001 10001110 11100110 00000110) (115772929)
      4     4                    (object header)                           71 00 00 00 (01110001 00000000 00000000 00000000) (113)
      8     4                    (object header)                           05 c1 00 20 (00000101 11000001 00000000 00100000) (536920325)
     12     4                int T.m1                                      123
     16     8               long T.m2                                      456
     24     4   java.lang.String T.m3                                      (object)
     28     4                    (loss due to the next object alignment)
Instance size: 32 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

可以发现，实例数据由m1、m2、m3组成，分别占用4字节、8字节、4字节。
代码中打印了该对象的hashCode为7106e68e，该对象的MarkWord信息如下(可以发现，这里的取值是倒过来的)：

00000000 00000000 00000000 01110001 00000110 11100110 10001110 00000001
（00 00 00 71 06 e6 8e 01）

可以看到，最后的3bit（1bit标识偏向锁，2bit描述锁的类型）是跟锁相关的，而Synchronized的锁优化升级就是修改的这几位上的标识用来区分不同的锁，从而采取不同的策略来提升性能。

锁的升级与对比

Java SE 1.6为了减少获得锁和释放锁带来的性能消耗，引入了“偏向锁”和“轻量级锁”，在Java SE 1.6中，锁一共有4种状态，级别从低到高依次是：无锁状态、偏向锁状态、轻量级锁状态和重量级锁状态，这几个状态会随着竞争情况逐渐升级。锁可以升级但不能降级，意味着偏向锁升级成轻量级锁后不能降级成偏向锁。这种锁升级却不能降级的策略，目的是为了提高获得锁和释放锁的效率。

偏向锁

HotSpo的作者经过研究发现，大多数情况下，锁不仅不存在多线程竞争，而且总是由同一线程多次获得，为了让线程获得锁的代价更低而引入了偏向锁。

当一个线程访问同步块并获取锁时，会在对象头和栈帧中的锁记录里存储锁偏向的线程ID，以后该线程在进入和退出同步块时不需要进行CAS操作来加锁和解锁，只需简单地测试一下对象头的Mark Word里是否存储着指向当前线程的偏向锁。如果测试成功，表示线程已经获得了锁。如果测试失败，则需要再测试一下Mark Word中偏向锁的标识是否设置成1（表示当前是偏向锁）：如果设置了，则尝试使用CAS将对象头的偏向锁指向当前线程；如果没有设置，则使用CAS竞争锁。

一旦出现另外一个线程去尝试获取这个锁的情况，偏向模式就马上宣告结束。根据锁对象目前是
否处于被锁定的状态决定是否撤销偏向（偏向模式设置为“0”），撤销后标志位恢复到未锁定（标志位
为“01”）或轻量级锁定（标志位为“00”）的状态。

偏向锁在Java 6和Java 7里是默认启用的，但是它在应用程序启动几秒钟之后才激活，如有必要可以使用JVM参数来关闭延迟：-XX:BiasedLockingStartupDelay=0。

// 如有必要可以使用JVM参数来关闭延迟：-XX:BiasedLockingStartupDelay=0
public class T {
    public static void main(String[] args) throws InterruptedException {
        System.out.println(ClassLayout.parseInstance(new T()).toPrintable());
        // 
        Thread.sleep(5*1000);
        System.out.println(ClassLayout.parseInstance(new T()).toPrintable());
    }
}

运行结果如下，可以发现程序启动后睡眠5秒，对象的偏向锁就打开了。

com.example.demo.test.T object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           05 c1 00 20 (00000101 11000001 00000000 00100000) (536920325)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

com.example.demo.test.T object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           05 00 00 00 (00000101 00000000 00000000 00000000) (5)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           05 c1 00 20 (00000101 11000001 00000000 00100000) (536920325)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

轻量级锁

（1）轻量级锁加锁线程在执行同步块之前，JVM会先在当前线程的栈桢中创建用于存储锁记录的空间，并将对象头中的Mark Word复制到锁记录中，官方称为Displaced Mark Word。然后线程尝试使用CAS将对象头中的Mark Word替换为指向锁记录的指针。如果成功，当前线程获得锁，如果失败，表示其他线程竞争锁，当前线程便尝试使用自旋来获取锁。

如果出现两条以上的线程争用同一个锁的情况，那轻量级锁就不再有效，必须要膨胀为重量级锁，锁标志的状态值变为“10”，此时Mark Word中存储的就是指向重量级锁（互斥量）的指针，后面等待锁的线程也必须进入阻塞状态。

（2）轻量级锁解锁轻量级解锁时，会使用原子的CAS操作将Displaced MarkWord替换回到对象头，如果成功，则表示没有竞争发生。如果失败，表示当前锁存在竞争，锁就会膨胀成重量级锁。

重量级锁

当系统检查到锁是重量级锁之后，将想要获得锁的线程进行阻塞，被阻塞的线程不会消耗CPU。但是阻塞或者唤醒一个线程时，都需要操作系统来帮忙，这就需要从用户态转换到内核态，而转换状态是需要消耗很多时间的，有可能比用户执行代码的时间还要长。

优缺点

实验

/**
 * 关闭偏向锁的延迟
 * -XX:BiasedLockingStartupDelay=0
 */
public class T {
    public static void main(String[] args) throws InterruptedException {
        T obj = new T();
        System.out.println("########## " + Thread.currentThread().getName() + " ##########");
        System.out.println(ClassLayout.parseInstance(obj).toPrintable());

        new Thread(() -> {
            synchronized (obj) {
                System.out.println("########## " + Thread.currentThread().getName() + " ##########");
                System.out.println(ClassLayout.parseInstance(obj).toPrintable());
            }
        },"A线程").start();

        new Thread(() -> {
            synchronized (obj) {
                System.out.println("########## " + Thread.currentThread().getName() + " ##########");
                System.out.println(ClassLayout.parseInstance(obj).toPrintable());
            }
        },"B线程").start();
    }
}

运行结果可能出现以下几种情况

偏向锁->偏向锁->轻量级锁

偏向锁->偏向锁->轻量级锁，这个情况需要多运行几次才会出现

########## main ##########
com.example.demo.test.T object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           05 00 00 00 (00000101 00000000 00000000 00000000) (5)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           05 c1 00 20 (00000101 11000001 00000000 00100000) (536920325)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

########## A线程 ##########
com.example.demo.test.T object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           05 d8 29 19 (00000101 11011000 00101001 00011001) (422172677)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           05 c1 00 20 (00000101 11000001 00000000 00100000) (536920325)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

########## B线程 ##########
com.example.demo.test.T object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           70 ef 1c 1a (01110000 11101111 00011100 00011010) (438103920)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           05 c1 00 20 (00000101 11000001 00000000 00100000) (536920325)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

偏向锁->轻量级锁->重量级锁

偏向锁->轻量级锁->重量级，这个情况需要多运行几次才会出现

com.example.demo.test.T object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           05 00 00 00 (00000101 00000000 00000000 00000000) (5)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           05 c1 00 20 (00000101 11000001 00000000 00100000) (536920325)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

########## A线程 ##########
com.example.demo.test.T object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           90 f0 d7 1a (10010000 11110000 11010111 00011010) (450359440)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           05 c1 00 20 (00000101 11000001 00000000 00100000) (536920325)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

########## B线程 ##########
com.example.demo.test.T object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           ba 8c 74 03 (10111010 10001100 01110100 00000011) (57969850)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           05 c1 00 20 (00000101 11000001 00000000 00100000) (536920325)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

偏向锁->偏向锁->重量级锁

########## main ##########
com.example.demo.test.T object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           05 00 00 00 (00000101 00000000 00000000 00000000) (5)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           05 c1 00 20 (00000101 11000001 00000000 00100000) (536920325)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

########## A线程 ##########
com.example.demo.test.T object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           05 08 bb 19 (00000101 00001000 10111011 00011001) (431687685)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           05 c1 00 20 (00000101 11000001 00000000 00100000) (536920325)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

########## B线程 ##########
com.example.demo.test.T object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           0a cb f1 17 (00001010 11001011 11110001 00010111) (401722122)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           05 c1 00 20 (00000101 11000001 00000000 00100000) (536920325)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

偏向锁->重量级锁->重量级锁

########## main ##########
com.example.demo.test.T object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           05 00 00 00 (00000101 00000000 00000000 00000000) (5)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           05 c1 00 20 (00000101 11000001 00000000 00100000) (536920325)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

########## A线程 ##########
com.example.demo.test.T object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           2a 8c 9e 03 (00101010 10001100 10011110 00000011) (60722218)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           05 c1 00 20 (00000101 11000001 00000000 00100000) (536920325)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

########## B线程 ##########
com.example.demo.test.T object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           2a 8c 9e 03 (00101010 10001100 10011110 00000011) (60722218)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           05 c1 00 20 (00000101 11000001 00000000 00100000) (536920325)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
lizc_lizc
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
从 Java 代码到 Java 堆
zhenaikeke
03-30 267
  背景信息：Java 进程的内存使用 参考知识 如需进一步了解 Java 应用程序的进程内存使用，请参阅 Andrew Hall 撰写的 developerWorks 文章 “内存详解”。这篇文章介绍了 内存详解 以及 AIX® 提供的布局和用户空间，以及 Java 堆和本机堆之间的交互。 通过在命令行中执行 java 或者启动某种基于 Java 的中间件来运行 Java...
Java 内存布局
只是个人笔记，请见谅
02-28 356
值拷贝与引用拷贝 数组是引用类型 1.基本数据类型，直接在栈中分配值 2.引用类型，先在堆中开辟了一个数据空间(对数据的操作都在堆中进行)，然后把该数据空间地址给栈中对应的变量名 3.值拷贝：基本数据类型是直接将值进行拷贝，不会对源数据造成影响 4.引用拷贝：引用类型拷贝，拷贝的是数据空间地址，也就是两个变量操作的是同一个数据空间，自然其中一个变量操作改变数据，会对另一个变量造成影响 二维数组的内存布局 1.在堆中创建一个长度为行个数大小的一维数组(假设为A数组) 2.A数组中每个元素再指向一个长度为列个
千万别忽视基础！十张图带你一步步理解Java内存结构！
最新发布
程序员世杰
07-01 1376
本文笔者将为大家详解Java内存结构。
JAVA内存布局
weixin_39478044的博客
01-30 263
java对象布局：java object layout 1，对象头（object header） Mark Word：存储了对象的hashCode、GC信息、锁信息三部分 class pointer：存储了指向类对象信息的指针。 在32位JVM上对象头占用的大小是8字节，64位JVM则是16字节 在64位JVM上有一个压缩指针选项-XX:+UseCompressedOops，默认是开启的。 开启之后Class Pointer部分就会压缩为4字节，此时对象头大小就会缩小到12字节。 数组：length(如果是
Java对象的内存布局
giantpoplar的专栏
08-14 2893
本文包括对简单java对象内存布局的介绍，介绍一个对象的大小，成员在内存中的位置等，不包括继承情况下布局的介绍
Java 对象的内存布局
weixin_34038652的博客
11-09 113
一个Java 对象在在内存中的存储布局分为3 块区域（HostSpot VM）： 对象头（Header） 实例数据（Instance Data） 对齐填充 1. 对象头 对象头的信息主要包括两个部分： Mark Word 类型指针 数组长度（如果是数组才有） 1.1 Mark Word Mark Word 的定义： Mark Word 用于存储对象自身的运行时数据，如哈希码（HashCo...
Java对象内存布局（全网最全图文详解）
uuqaz的博客
03-07 4767
作为一名Java程序员，我们在日常工作中使用这款面向对象的编程语言时，做的最频繁的操作大概就是去创建一个个的对象了。对象的创建方式虽然有很多，可以通过new、反射、clone、反序列化等不同方式来创建，但最终使用时对象都要被放到内存中，那么你知道在内存中的java对象是由哪些部分组成、又是怎么存储的吗？ 本文将基于代码进行实例测试，详细探讨对象在内存中的组成结构。全文目录结构如下： 1、对象内存结构概述 2、JOL 工具简介 3、对象头 4、实例数据 ...
java对象内存布局及大小
小小葩的博客
10-12 589
输出结果如下图，表示当前虚拟机的配置信息。每个人的机器可能配置不太一样，我这个不是绝对的。最后的4个字节就是自动对齐padding的，凑够32字节，正好是8的倍数。classPointer 不开启压缩，oops也不开启压缩。classPointer不开启压缩，oops开启压缩。classPointer开启压缩，oops不开启压缩。总大小32字节，无padding。实际上都没有压缩，总大小48字节。结果同实操三一样，48字节.2.构建几个简单的基础类。
10Java对象的内存布局1
08-04
Java对象的内存布局是Java虚拟机（JVM）中至关重要的一部分，它涉及到对象创建、内存分配以及对象访问等核心概念。在Java程序中，我们通常使用`new`关键字创建对象，但这只是表面操作，背后涉及的内存管理和构造器...
Java内存布局【图】以及java各种存储区【详解】
Wait的专栏
08-23 5976
Java内存布局浅谈
【Java】Java 如何查看对象的内存布局
九师兄
12-05 621
1.概述 在一些博客中说java的内存布局是分为3个部分的，那么我们怎么确认这个呢？或者如何打印java 对象的内存布局呢？ 下面介绍可以使用这个类 首先引入这个包 <dependency> <groupId>org.openjdk.jol</groupId> <artifactId>jol-core</artifactId> <version>0.
java内存布局_JVM内存布局
weixin_33293612的博客
02-25 113
Run-Time Data Areas(JVM)运行时数据(内存)区域(布局)包含了六个部分；1)The pc Register(生命周期与Thread相同)：pc寄存器又称程序计数器，用来存储各个线程当前要执行的指令集的地址。2)Java Virtual Machine Stacks(生命周期与Thread相同)：Java虚拟机栈，栈中存的是Frame帧，帧中存储的是局部变量和部分返回结果。可以...
java-内存布局
h1774733219的博客
07-03 437
实例数据 对齐填充 64位jvm下是按照8字节读取数据的，例如以下每个格子代表一个字节：每次读取8个字节 这是没有进行对齐填充的 没有对齐的话，想要读取long型的这个完整数据：需要先读取0x00-0x07这8字节，再读取0x08-0x0f这8字节，整合两次读取的结果才能得到真正的数据 如果是对齐填充的 只需要读取一次0x08-0x0f这八字节就能获取到数据主要针对堆：以下的非堆指的是方法区 流程图 永久代： 元空间......
java内存布局_Java对象内存布局
weixin_42561464的博客
02-20 121
对象的创建过程当Java虚拟机遇到一条字节码 new 指令时。首先将去检查这个指令的参数是否能在常量池中定位到一个类的符号引用。并检查这个符号引用代表的类是否已被加载、解析和初始化过。如果没有，则必须先执行相应的类的加载过程。分配内存空间。将分配到的内存空间都初始化为零值。对对象头进行必要的设置。执行方法，按照程序的意愿进行初始化。对象的内存布局对象在堆内存中的存储布局可以划分为三个部分：对象头(...
Juc18_Java内存模型、对象头Mark Word、实例数据、对齐填充、谈谈new Object( )占多大内存
所得皆惊喜
06-23 3120
文章目录①. 对象在堆内存中的存储布局②. 对象头(Header)①. 对象标记Mark Word②. 类元信息(又叫类型指针)③. 对象头多大③. 实例数据④. 对齐填充⑤. 总结⑥. 再说对象头的MarkWord⑦. 聊聊Object obj = new Object() ①. 对象在堆内存中的存储布局 ①. 对象内部结构分为:对象头、实例数据、对齐填充(保证8个字节的倍数)。 ②. 对象头分为对象标记(markOop)和类元信息(klassOop),类元信息存储的是指向该对象类元数据(kla
java虚拟机内存布局
菜鸟升职记的专栏
02-13 1336
java虚拟机运行时数据区： java虚拟机在执行java程序时，将其所管理的内存，划分为若干个数据区域。其中包括：程序计数器，方法区，堆，虚拟机栈，本地方法栈。 下面一一进行解释。1.程序计数器：当前线程执行字节码的行号指示器，保存cpu执行当前指令的地址，cpu从程序计数器中获得指令的执行地址，程序计数器便自动加1或者根据转移指针得到下一条指令的地址。<1>在多线程任务调度中，cpu轮流执行
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值