精华内容
下载资源
问答
  • 对象占用内存大小怎么计算
    千次阅读
    2014-07-24 23:02:31

    案例一:

    User

    public class User {
    	
    	
    }

    UserSizeTest

    public class UserSizeTest {
    	static final Runtime runTime=Runtime.getRuntime();
    	public static void main(String[] args) {
    		final int count = 100000;
    		User[] us=new User[count];
    		
    		long heap1 = 0;
    		
    		for (int i = -1; i < count; ++i) {
    			User user=null ;
    			user=new User();
    			if (i >= 0)
    				us[i] = user;
    			else {
    				user = null; 
    				heap1 = getUsedMemory(); 
    			}
    		}
    		long heap2 = getUsedMemory();
    		System.out.println("user大小:"+((float)heap2-heap1)/count+" bytes");
    		for (int i = 0; i < count; i++) {
    			us[i]=null;
    		}
    		runTime.gc();
    	}
    	static long getUsedMemory(){
    		return runTime.totalMemory()-runTime.freeMemory();
    	}
    }

    结果:

    user大小:7.62576 bytes


    说明:

    空对象占用8个字节




    案例二:

    public class User {
    	boolean flag;
    	long id;
    	Date date ;
    	
    }

    运行测试类结果;

    user大小:23.50192 bytes

    说明:

    boolean 1+ long 8 + 引用类型 Date 4 =13 凑齐8的倍数 =16
    	
    16+空对象 8 =24


    更多相关内容
  • 怎么计算Java对象占用多少内存,对象的内存结构 背景 Object obj = new Object() 这个对象在堆中占用多少字节?要知道答案,先要知道Java对象的结构,即是由什么部分组成的? 注意本文谈的都是64位虚拟机。 Java对象...

    怎么计算Java对象占用多少内存,对象的内存结构

    背景

    Object obj = new Object() 这个对象在堆中占用多少字节?要知道答案,先要知道Java对象的结构,即是由什么部分组成的?

    注意本文谈的都是64位虚拟机。

    Java对象在内存中的组成

    一个Java对象,在堆中究竟占多大内存?怎么计算? 首先它是由4部分组成的

    • mark word
    • klass pointer(类指针,指向Xxx.class 的)
    • Instance data
    • padding

    Mark word 固定的8字节;

    Klass pointer 开启了指针压缩则4字节,否则8字节(-XX:+UseCompressedOops默认是开启的);

    instance data:原始类型和引用分别占用

    boolean -> 1字节;byte -> 1字节;short -> 2字节;char -> 2字节;int -> 4字节;float -> 4字节;long -> 8字节;double -> 8字节;Reference(引用类型)-> 开启了指针压缩则4字节,否则8字节(跟前面的Klass pointer是一样的 JVM参数控制

    padding:就是填充,即上面的加起来之后如果不是8的倍数,会填充成8的倍数。

    例外:数组也是对象,数组在上述的基础上,还多了数组长度,占用4字节(这个比较抽象,详细见题目加深理解

    题目

    1、Object obj = new Object() 这个对象占用多少字节?

    解答:假设开启了指针压缩,则

    mark word:8字节

    klass pointer:4字节

    instance data:0字节,你翻看源码,看到没有任何的变量。

    padding:上述加起来是12,则至少要凑成16,即padding是4字节

    所以答案是16字节。当然不开指针压缩的话是8+8+0+0,也是16字节(padding不需要凑了)。

    2、如下的类被new出来后占用多少?

    public class Student {
      private String name;
      private int age;
      private boolean married;
      private Course[] courses;
    }
    假设开启了压缩,name和courses都是引用类型,各占用4字节,age是int占用4字节,married占用1字节所以instance data是13字节,所以
    8(mark word)+4(klass pointer)+13(instance data)=25字节,必须凑成8的整数,即padding=7字节,故最后算出对象占用32字节。
    

    3、计算数组的占用

    Integer[] arr = new Integer[0];
    arr占用多少?
    mark word 8字节;klass pointer 4字节(开启了压缩);数组长度 4字节(固定的);由于数组长度是0,instance data是0。
    上述加起来是16字节,不需要padding,所以最终是16字节。
      
    Integer[] arr = new Integer[3];
    mark word 8字节;klass pointer 4字节(开启了压缩);数组长度 4字节(固定的);数组长度是3,Integer是引用类型,开启压缩的情况下1个Integer的引用占用4字节,所以3个的话是12字节;
    上述加起来是28字节,需要padding为4字节,最终凑成32字节。
    
    
    展开全文
  • 主要介绍了Python实现计算对象的内存大小,结合实例形式分析了Python使用sys.getsizeof与递归算法计算对象占用内存的相关操作技巧,需要的朋友可以参考下
  • C#计算对象占用内存大小(.net)

    千次阅读 2020-06-13 10:56:56
    影响对象占用多大空间的主要因素如下: 1:字段个数 2:字段类型 3:字段布局 二.字段类型 先来看一下,主要数据类型在32位系统和64位系统中的字节长度: 从上面可以得知只有指针类型变成了8个字节,因为指针里面...

    我们写了很多的代码,但是有没有想过每写一句代码会占用多大空间呢,现在就来算一下。

    一.对象大小

    影响对象占用多大空间的主要因素如下:
    1:字段个数
    2:字段类型
    3:字段布局

    二.字段类型

    先来看一下,主要数据类型在32位系统和64位系统中的字节长度:
    在这里插入图片描述
    在这里插入图片描述
    从上面可以得知只有指针类型变成了8个字节,因为指针里面存储的是数据的地址,而非数据本身,所以会变为2倍。

    三.布局

    在clr中,布局一共有三种:
    1:LayoutKind.Auto:clr会优化字段排序。
    2:LayoutKind. Sequential :clr不会优化字段排序,按照代码顺序进行布局。
    3:LayoutKind. Explicit:每个字段必须设置FieldOffset,来决定字段的布局。

    四.预测对象占用的空间

    根据LayoutKind的设置,布局会有所不同,以下都是以32位操作系统为例:

    1:PeopleAuto类采用LayoutKind.Auto布局,clr会优化字段排序,将两个bool行的字段放到了后面,不够就补齐四个字节,外加同步块索引和类型对象指针,所以一共占20个字节。
    在这里插入图片描述
    2:PeopleSequential类采用LayoutKind. Sequential布局,clr不会优化字段排序,按照代码顺序进行布局,不够就补齐四个字节,外加同步块索引和类型对象指针,所以一共占24个字节。
    在这里插入图片描述
    3:PeopleExplicit类采用LayoutKind. Explicit:每个字段必须设置FieldOffset,来决定字段的布局,不够就补齐四个字节。由于三个字段的FieldOffset都设置为0,外加同步块索引和类型对象指针,所以一共占16个字节。
    在这里插入图片描述

    五.验证对象占用的空间

    1:PeopleAuto类:通过windbg查看,PeopleAuto占用的空间为20byte,和理论值一样,布局也和预测的一样,如下:
    在这里插入图片描述
    2:PeopleSequential类:通过windbg查看, PeopleSequential只占用了空间为20byte,和理论值(24byte)不一样,布局也不一样。Clr还是做了优化。(这里还是需要做进一步的研究)
    在这里插入图片描述
    3:PeopleExplicit类:通过windbg查看, PeopleExplicit占用的空间为16byte,和理论值一样。布局也和预测的一样。
    在这里插入图片描述

    六.总结

    1:32位操作系统和64位操作系统,只有指针的长度从4byte变成了8byte,其他类型字段没有区别。
    2:字段个数、字段类型和布局决定对象占用空间大小。
    3: LayoutKind.Auto: clr会优化字段排序。
    4: LayoutKind. Sequential: 按照代码顺序进行布局。(如果优化能起到减小空间的话,那还是会优化的,还需要进一步研究)
    5: LayoutKind. Explicit:通过指定字段的布局来控制字段大小,从而改变默认布局。
    6:字段字节过小,会发生字段补齐,占满4或8个字节。

    展开全文
  • Java 对象占用内存大小

    千次阅读 2018-01-22 13:35:25
    如果想要了解java对象内存中的大小,必须先要了解java对象的结构。 HotSpot虚拟机中,对象内存中存储的布局可以分为三块区域:对象头(Header)、实例数据(Instance Data)和对齐填充(Padding) java 对象...

    Java 对象

    如果想要了解java对象在内存中的大小,必须先要了解java对象的结构。

    HotSpot虚拟机中,对象在内存中存储的布局可以分为三块区域:对象头(Header)、实例数据(Instance Data)和对齐填充(Padding)

    java 对象头

    • Mark Word
      HotSpot虚拟机的对象头(Object Header)包括两部分信息,第一部分用于存储对象自身的运行时数据, 如哈希值(HashCode)、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等等,这部分数据的长度在32位和64位的虚拟机(暂 不考虑开启压缩指针的场景)中分别为32个和64个Bits,官方称它为“Mark Word”。

    • Class Metadata Address
      存储该对象的 Class 对象的地址。就是该对象属于那个Class。

    • ArrayList
      存储数组的长度。
      如果是数组对象才会有此数据。非数组对象没有此数据。

    具体对象头占用的大小如下:

    长度内容说明
    32/64 bitMark Word存储对象的 hashCode 或锁信息等
    32/64 bitClass Metadata Address存储到对象类型数据的指针
    32/64 bitArrayList数组的长度(如果当前对象是数组)

    从上面表格中,我们可以推断出:

    32位系统:

    • 对象头占用:32+32=64bit。 64bit/8=8byte。
    • 数组对象头占用:32+32+32=96bit。 96bit/8=12byte。

    64位系统:

    对象头占用:64+64=128bit。128bit/8=16byte。
    数组对象头占用:64+64+64=192bit。 192bit/8=24byte。

    实例数据

    实例数据就是,对象中的实例变量。
    实例变量类型分为:基本类型和引用类型。

    类型32位系统占用空间64位系统占用空间
    boolean1 byte1 byte
    byte1 byte1 byte
    char2 byte2 byte
    short2 byte2 byte
    int4 byte4 byte
    float4 byte4 byte
    long8 byte8 byte
    double8 byte8 byte
    ref4 byte8 byte

    对齐填充

    对象在堆中分配的最新存储单位是8byte。如果存储的数据不够8byte的倍数,则对齐填充够8的倍数个字节。

    Java 对象大小分析

    下面我们以 64 位的 JDK 进行分析 Java 对象在堆中的占用空间大小

    代码示例一

    public class StrObj1 {
        private String a;
    }
    public class StrObj2 {
        private String a;
        private String b;
    }
    public class StrObj3 {
        private String a;
        private String b;
        private String c;
    }
    public class StrObj4 {
        private String a;
        private String b;
        private String c;
        private String d;
    }
    public class NumObj {
        private int a;
        private int b;
        private int c;
        private int d;
    }
    public class Obj {
        public static void main(String[] args) {
            Obj obj = new Obj();
            StrObj1 s1 = new StrObj1();
            StrObj2 s2 = new StrObj2();
            StrObj3 s3 = new StrObj3();
            StrObj4 s4 = new StrObj4();
            Obj[] arrObj = new Obj[10];
            NumObj num = new NumObj();
                    //System.gc()  会出发 FullGC。
            System.gc();
        }
    }

    运行程序

    java -XX:+HeapDumpBeforeFullGC -XX:HeapDumpPath=D:\hprof\test2.hprof -XX:-UseCompressedOops cn.com.infcn.jmat.ObjectAnalyze

    启动参数说明:

    -XX:+UseCompressedOops
    开启指针压缩。(默认开启,该参数对64位虚拟机有用)
    -XX:-UseCompressedOops
    关闭指针压缩。
    其它参数具体 JVM 参数解释详见:生成 Heap Dump 的几种方式

    因为 System.gc(); 会出发FullGC,配合-XX:+HeapDumpBeforeFullGC 参数,会在 FullGC 前会在生成一个堆dump文件:D:\hprof\test2.hprof

    分析dump

    本案例,使用 jmat 工具进行分析 dump 文件。

    cn.com.infcn.jmat.Obj 对象分析

    从图中我们发现 cn.com.infcn.jmat.Obj 对象占用 16 byte 空间。
    非数组64位的对象头 占用16字节,而且改对象没有属性,16字节正好也是8的倍数,不需要填充,所以占用堆空间久违16字节。

    cn.com.infcn.jmat.StrObj1

    图中可以看出 cn.com.infcn.jmat.StrObj1 对象占用 24 byte 空间。

    对象头 16 byte
    1 个引用类型实例变量
    16 + 8 = 24 byte

    cn.com.infcn.jmat.StrObj2

    图中可以看出 cn.com.infcn.jmat.StrObj1 对象占用 32 byte 空间

    对象头 16 byte
    2 个引用类型实例变量
    16 + 2 * 8 = 32 byte

    cn.com.infcn.jmat.StrObj3

    图中可以看出 cn.com.infcn.jmat.StrObj1 对象占用 40 byte 空间

    对象头 16 byte
    3 个引用类型实例变量
    16 + 3 * 8 = 40 byte

    cn.com.infcn.jmat.StrObj4

    图中可以看出 cn.com.infcn.jmat.StrObj1 对象占用 48 byte 空间

    对象头 16 byte
    4个引用类型实例变量
    16 + 4 * 8 = 48 byte

    cn.com.infcn.jmat.NumObj

    图中可以看出 cn.com.infcn.jmat.NumObj 对象占用 32 byte 空间

    4个 int 类型实例变量
    16 + 4 * 4 = 32 byte

    cn.com.infcn.jmat.Obj[] 数组

    图中可以看出 cn.com.infcn.jmat.Obj[] 对象占用 104 byte 空间

    数组对象头 24 byte
    10 个 Obj 的引用。
    24 + 8 * 10 = 104 byte

    对象数组中存储的是对象的引用,而不是实际的数据。

    代码示例 二

    public class BooleanObj1 {
        boolean a;
    }
    
    ......
    
    public class BooleanObj8 {
        boolean a;
        boolean b;
        boolean c;
        boolean d;
        boolean e;
        boolean f;
        boolean g;
        boolean h;
    }
    public class BooleanObj9 {
        boolean a;
        boolean b;
        boolean c;
        boolean d;
        boolean e;
        boolean f;
        boolean g;
        boolean h;
        boolean i;
    }

    以指针非压缩方式执行,然后分析dump。

    从图中我们发现 BooleanObj1 和 BooleanObj8 大小一样都是24。
    而 BooleanObj9 的大小为32。

    BooleanObj1

    对象头 16 byte
    1 个 boolean 实例变量。

    16 + 1 = 17 byte。
    因为 17 byte 不是 8 的倍数,需要 对齐填充
    所以BooleanObj1 所占空间为 24 byte。

    BooleanObj8

    对象头 16 byte
    8 个 boolean 实例变量。

    16 + 8 = 24 byte。

    BooleanObj9

    对象头 16 byte
    9 个 boolean 实例变量

    16 + 9 =25 byte
    对齐填充 后为 32 byte


    想了解更多精彩内容请关注我的公众号

    展开全文
  • 测试java对象占用内存大小的例子,可以测试常用的类型
  • 查看java对象占用内存大小

    千次阅读 2019-10-31 21:39:55
    的方法输出对象占用大小信息: package com . pilaf . classlayout ; import lombok . Data ; /** * @description: * @author: pilaf * @create: 2019-10-31 21:17 */ @Data public class ...
  • java取得对象占用内存大小

    千次阅读 2020-05-19 14:34:51
    一、通过Instrumentation获取内存 在java工程中添加如下代理类: package com.nineya.memorymeasurs; import java.lang.instrument.Instrumentation; public class MemoryMeasurs { static Instrumentation ...
  • java 查看对象内存占用大小

    千次阅读 2022-04-27 17:18:02
    1、POM 依赖 <dependency> <groupId>com.carrotsearch</groupId> <artifactId>java-sizeof<.../2、java 代码通过RamUsageEstimator 查看内存占用大小 String str = "xxx";
  • 如何计算Java对象所占内存大小

    万次阅读 多人点赞 2018-05-24 11:42:12
    摘要:本文以如何计算Java对象占用内存大小为切入点,在讨论计算Java对象占用堆内存大小的方法的基础上,详细讨论了Java对象头格式并结合JDK源码对对象头中的协议字段做了介绍,涉及内存模型、锁原理、分代GC、OOP-...
  • 一、已经持有了Bitmap对象,怎么知道它占用内存大小 bitmap类本身 就有这个方法, bitmap.getByteCount()就行。它内部是计算方式:每一行的字节大小 * 总行数(即高度) android.graphics.Bitmap.java 源码 ...
  • 计算对象占用大小
  • 前言 最近在公司需要对导出各种类型的报表进行...3.第三方内存大小计算工具 对象占用内存的基本组成结构 对象内存占用计算 以下面类为例 class People{ int age = 20; String name = "Xiaoming"; } class Person ex
  • 本文讲述4种查看java对象所占内存大小的方法
  • Java对象内存大小计算

    万次阅读 多人点赞 2018-07-03 14:43:34
    最近在读《深入理解Java虚拟机》,对Java对象内存布局有了进一步的认识,于是脑子里自然而然就有一个很普通的问题,就是一个Java对象到底占用多大内存? 在网上搜到了一篇博客讲的非常好:...
  • JVM对象占用内存计算

    千次阅读 2019-11-05 21:33:41
    接下来我将介绍对象占用内存大小计算方式,首先从java对象模型说起。 Java的对象模型 java是面向对象的语言,每个对象都属于某个类。在HotSpot虚拟机中对象采用的是oop-klass模型。其实原理很简单:就是在方法区...
  • 2. 计算内存大小,返回MB private int getMb(Object obj) { if (obj == null) { return 0; } //计算指定对象本身在堆空间的大小,单位字节 long byteCount = RamUsageEstimator.shallowSizeOf(obj); if ...
  • java对象占用内存大小计算方法

    千次阅读 2010-11-15 15:33:00
    java对象占用内存大小计算方法 统计HashMap存储量大小。
  • Android中获取和计算Bitmap占用内存大小 Bitmap、ARGB_8888、RGB_565、getAllocationByteCount、getByteCount
  • 如何获取一个Java对象所占内存大小

    千次阅读 2021-02-26 12:51:59
    获取JAVA对象占用内存大小 介绍两种获取JAVA对象内存大小的方法. 第一种:Instrumentation 简介: 使用java.lang.instrument 的Instrumentation来获取一个对象的内存大小.利用I ... JAVA数组所占内存大小的对比 1....
  • 一句话权威总结如下: 一个类对象需要占用多大的内存空间: 非静态成员变量总和加上编译器为了CPU计算作出的数据对齐处理和支持虚函数所产生的负担的总和。
  • Java一个对象占用内存大小查看

    千次阅读 2019-05-10 20:13:40
    BigDecimal b =BigDecimal.valueOf( RamUsageEstimator.sizeOf("要测量的对象")); BigDecimal divide = b.divide(BigDecimal.valueOf(1024 * 1024)); log.info("DrivingController 数据大小:{} M", divide....
  • 一、如果想看运行时某个java对象占用JVM内存大小,可以先将对象转换成字节类型,然后计算:List bizGroupRelatedEventInfos = bizEventVersionMapper.selectRelatedEventInfoByGroupIdsAndType(bizSdkGroupIds,...
  • 统计缓存大小(查看java对象所占的内存大小).
  • 怎么计算一个对象占用内存

    千次阅读 2019-04-12 01:28:45
    怎么计算一个对象占用的内存 这应该是很多人在面试过程中遇到过的一个面试题~ 好多人在听到这么一个问题的时候都会瞬间懵逼,也有的人我记住了基本数据类型的占用内存和对象引用是4个字节大小。 这是正确的思考方向...
  • 近似计算一个对象在js占用内存

    千次阅读 2019-10-01 03:24:26
    在很久之前,我就想查看一个对象在JS里占用多少内存了,直到最近由于线上使用了需要计算从服务端传输数据的大小,让这个需求尤为强烈。 预备知识 我们现在使用的js是高级语言,它在内存细节之上建立一个抽象层,目前...
  • 查看java对象内存占用

    千次阅读 2022-03-21 15:33:03
    } } 结果: JVM 要求对象所占的内存空间大小是8字节的整数倍,而对象本来占17字节,加上补齐的 7 字节,一共占24字节(8字节 * 3) myTest:MyTest(a=0, b=false) # WARNING: Unable to attach Serviceability Agent....
  • 文章目录1 类的对象占用内存大小1.1 空类的Size1.2 只有成员变量的Size1.3 只有成员函数的Size1.4 类的对象成员函数不占用对象内存区2 类的对象存储位置和对齐规则2.1 test case 12.2 test case 22.3 test case 32.4...
  • C++ 对象占用内存大小的思考

    千次阅读 2014-03-07 20:45:33
    一直有这样几个疑问,C++中一个对象占有多大内存?会不是里面的函数越多,占有的内存就越大? 1:空类占有的内存 #pragma once class TestClass { }; 结果:sizeof(TestClass) = 1 原因:C++要为每一个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 316,468
精华内容 126,587
热门标签
关键字:

对象占用内存大小怎么计算