精华内容
下载资源
问答
  • java对象占用内存大小计算方法

    千次阅读 2010-11-15 15:33:00
    java对象占用内存大小计算方法 统计HashMap存储量大小。

    public static void main(String[] args) {

    Map testMap = new HashMap();
                    Product p= null;
                    long start = 0;
                    long end = 0;
                    System.gc();
                    start = Runtime.getRuntime().freeMemory();
                    System.out.println("+++++++++++++++++测试HashMap开始++"+Formater.formatAsLong(new Date())+"++++++++++++++++");
                    for(int i=0;i<20000;i++){
                        p=new Product();//20个属性的大对象
                        p.setProductCode(i+"dfsdf");
                        p.setProductName(i+"namessssssdfsdfssss");
                        testMap.put(i, p);
                    }
                    //servletContext.setAttribute("productHashMap",testMap);
                    System.gc();
                    end = Runtime.getRuntime().freeMemory();
                    System.out.println("一个HashMap对象占内存:" + (start-end)/1024.0/1024.0);//MB
                    // 测试 2万条数据                     占26.96MB空间
                    // 测试 5万条数据比较轻松 占73.8MB空间
                    System.out.println("+++++++++++++++++测试HashMap结束+++++"+Formater.formatAsLong(new Date())+"++++Size:"+testMap.size()+"++++++++++++");

    }

    展开全文
  • java对象占用内存大小计算方式

    千次阅读 2014-07-24 23:02:31
    对象占用8个字节 案例二: public class User { boolean flag; long id; Date date ; } 运行测试类结果; user大小:23.50192 bytes 说明: ...

    案例一:

    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 对象占用内存大小

    千次阅读 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对象占用内存大小的例子,可以测试常用的类型
  • 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计算一个对象占用内存大小

    千次阅读 2015-05-27 17:13:02
    Java计算一个对象占用内存大小
  • Java对象占用内存大小

    千次阅读 2014-03-16 07:40:38
    Java对象占用内存大小   转 new Object()将占用多少bytes的内存空间?  原生类型(primitive type)的内存占用 Primitive Type Memory Required(bytes) ————————————————————— ...
  • 查看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 ...
  • JVM对象占用内存计算

    千次阅读 2019-11-05 21:33:41
    接下来我将介绍对象占用内存大小计算方式,首先从java对象模型说起。 Java的对象模型 java是面向对象的语言,每个对象都属于某个类。在HotSpot虚拟机中对象采用的是oop-klass模型。其实原理很简单:就是在方法区...
  • C++ 对象占用内存大小的思考

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

    万次阅读 2016-03-22 22:04:30
    为什么要知道 Java 对象占用空间大小? Java 里面一切都是对象,每天都在使用的 Java 对象占据多少内存空间,原来竟是这样...
  • 2. 计算内存大小,返回MB private int getMb(Object obj) { if (obj == null) { return 0; } //计算指定对象本身在堆空间的大小,单位字节 long byteCount = RamUsageEstimator.shallowSizeOf(obj); if ...
  • java Object类占用内存大小计算

    千次阅读 2015-08-11 23:31:25
    在Java中,一个空Object对象大小是8byte,这个大小只是保存堆中一个没有任何属性的对象大小。看下面语句: Object ob = new Object();  这样在程序中完成了一个Java对象的生命,但是它所占的空间为:...
  • 主要介绍了Python实现计算对象的内存大小,结合实例形式分析了Python使用sys.getsizeof与递归算法计算对象占用内存的相关操作技巧,需要的朋友可以参考下
  • 计算对象占用大小
  • Java对象内存大小计算

    千次阅读 2018-07-03 14:43:34
    最近在读《深入理解Java虚拟机》,对Java对象内存布局有了进一步的认识,于是脑子里自然而然就有一个很普通的问题,就是一个Java对象到底占用多大内存? 在网上搜到了一篇博客讲的非常好:...
  • 如何获取对象占用多大内存。读了一个11M的文本,分词用HashMap存起来,打印内存居然少了400M,想看看内存被谁占用了
  • JAVA对象所占内存大小计算例子,博文地址:http://blog.csdn.net/u012787710/article/details/53164226
  • java空对象占用内存大小

    千次阅读 2020-07-14 13:50:45
    JVM 对象头一般占用两个机器码,在 32-bit JVM 上占用 64bit, 在 64-bit JVM 上占用 128bit 即 8+8=16 bytes(开启指针压缩后占用 4+8=12 bytes) 64位机器上。数组对象对象占用 24 bytes,启用压缩之后占用...
  • 查看对象占用内存空间大小

    千次阅读 2018-05-10 10:32:43
    sys模块 sys.getsizeof
  • python查看对象占用内存空间大小

    万次阅读 2018-08-17 16:30:34
    python查看对象占用内存空间大小,一共两步 引用sys模块 使用getsizeof()方法 举例如下 import sys as sys a = [x for x in range(1000)] print sys.getsizeof(a) 完成!...
  • Java一个对象占用内存大小查看

    千次阅读 2019-05-10 20:13:40
    log.info("RamUsageEstimator数据大小:{}", RamUsageEstimator.sizeOf(assetDetailList));   3.数据转换     来源:  https://jingyan.baidu.com/article/cd4c297925f231756e6e600f.html ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 278,168
精华内容 111,267
关键字:

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