java小工具：sizeof，计算出实例的大小

最新推荐文章于 2021-02-13 09:09:50 发布
最新推荐文章于 2021-02-13 09:09:50 发布
阅读量1.5k 收藏 2
点赞数
分类专栏： java sizeof 文章标签： sizeof 计算出实例的大小
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/spark_guo/article/details/82620535
版权

背景：

前段时间，生产环境出现问题：日期不一致，然后发现：SimpleDateFormat不是线程安全的类。

为什么将SimpleDateFormat 变量静态化呢

static   SimpleDateFormat simpleDateFormat =  new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

初衷是每创建 simpleDateFormat 对象，需要比较大的内存。

问题：找到 创建一个simpleDateFormat 对象，需要多大的内存？

运行命令: java -javaagent:testload-0.0.1-SNAPSHOT.jar com.atzy.tango.test.SizeOfObjectTest

下载地址：https://download.csdn.net/download/spark_guo/10658391

以下是代码段，

package com.atzy.tango.test;
import java.lang.instrument.Instrumentation;  
import java.lang.reflect.Array;  
import java.lang.reflect.Field;  
import java.lang.reflect.Modifier;  
import java.util.ArrayDeque;  
import java.util.Deque;  
import java.util.HashSet;  
import java.util.Set;  
  
/**
 * 对象占用字节大小工具类  
 * @author Spark.Guo
 *
 * @version 创建时间：2018年9月3日  下午5:04:25
 */
public class SizeOfObject {  
    static Instrumentation inst;  
  
    public static void premain(String args, Instrumentation instP) {  
        inst = instP;  
    }  
  
    /** 
     * 直接计算当前对象占用空间大小，包括当前类及超类的基本类型实例字段大小、<br></br> 
     * 引用类型实例字段引用大小、实例基本类型数组总占用空间、实例引用类型数组引用本身占用空间大小;<br></br> 
     * 但是不包括超类继承下来的和当前类声明的实例引用字段的对象本身的大小、实例引用数组引用的对象本身的大小 <br></br> 
     * 
     * @param obj 
     * @return 
     */  
    public static long sizeOf(Object obj) {  
        return inst.getObjectSize(obj);  
    }  
  
    /** 
     * 递归计算当前对象占用空间总大小，包括当前类和超类的实例字段大小以及实例字段引用对象大小 
     * 
     * @param objP 
     * @return 
     * @throws IllegalAccessException 
     */  
    public static long fullSizeOf(Object objP) throws IllegalAccessException {  
        Set<Object> visited = new HashSet<Object>();  
        Deque<Object> toBeQueue = new ArrayDeque<Object>();  
        toBeQueue.add(objP);  
        long size = 0L;  
        while (toBeQueue.size() > 0) {  
            Object obj = toBeQueue.poll();  
            //sizeOf的时候已经计基本类型和引用的长度，包括数组  
            size += skipObject(visited, obj) ? 0L : sizeOf(obj);  
            Class<?> tmpObjClass = obj.getClass();  
            if (tmpObjClass.isArray()) {  
                //[I , [F 基本类型名字长度是2  
                if (tmpObjClass.getName().length() > 2) {  
                    for (int i = 0, len = Array.getLength(obj); i < len; i++) {  
                        Object tmp = Array.get(obj, i);  
                        if (tmp != null) {  
                            //非基本类型需要深度遍历其对象  
                            toBeQueue.add(Array.get(obj, i));  
                        }  
                    }  
                }  
            } else {  
                while (tmpObjClass != null) {  
                    Field[] fields = tmpObjClass.getDeclaredFields();  
                    for (Field field : fields) {  
                        if (Modifier.isStatic(field.getModifiers())   //静态不计  
                                || field.getType().isPrimitive()) {    //基本类型不重复计  
                            continue;  
                        }  
  
                        field.setAccessible(true);  
                        Object fieldValue = field.get(obj);  
                        if (fieldValue == null) {  
                            continue;  
                        }  
                        toBeQueue.add(fieldValue);  
                    }  
                    tmpObjClass = tmpObjClass.getSuperclass();  
                }  
            }  
        }  
        return size;  
    }  
  
    /** 
     * String.intern的对象不计；计算过的不计，也避免死循环 
     * 
     * @param visited 
     * @param obj 
     * @return 
     */  
    static boolean skipObject(Set<Object> visited, Object obj) {  
        if (obj instanceof String && obj == ((String) obj).intern()) {  
            return true;  
        }  
        return visited.contains(obj);  
    }  
}
package com.atzy.tango.test;
import static com.atzy.tango.test.SizeOfObject.fullSizeOf;
import static com.atzy.tango.test.SizeOfObject.sizeOf;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

import org.apache.commons.lang.time.DateFormatUtils;
import org.apache.commons.lang.time.DateUtils;
/**
 * 
 * @author Spark.Guo
 *
 * @version 创建时间：2018年9月3日  下午5:04:35
 */
public class SizeOfObjectTest {
    /**
     * -XX:+UseCompressedOops: mark/4 + metedata/8 + 4 = 16
     * -XX:-UseCompressedOops: mark/8 + metedata/8 + 4 + padding/4 = 24
     */
    static class A {
        int a;
    }

    /**
     * -XX:+UseCompressedOops: mark/4 + metedata/8 + 4 + 4 + padding/4 = 24
     * -XX:-UseCompressedOops: mark/8 + metedata/8 + 4 + 4 = 24
     */
    static class B {
        int a;
        int b;
    }

    /**
     * -XX:+UseCompressedOops: mark/4 + metedata/8 + 4 + 4 + padding/4 = 24
     * -XX:-UseCompressedOops: mark/8 + metedata/8 + 8 + 4 + padding/4 = 32
     */
    static class B2 {
        int b2a;
        Integer b2b;
    }

    /**
     * 不考虑对象头：
     * 4 + 4 + 4 * 3 + 3 * sizeOf(B)
     */
    static class C extends A {
        int ba;
        B[] as = new B[3];

        C() {
            for (int i = 0; i < as.length; i++) {
                as[i] = new B();
            }
        }
    }

    static class D extends B {
        int da;
        Integer[] di = new Integer[3];
    }

    /**
     * 会算上A的实例字段
     */
    static class E extends A {
        int ea;
        int eb;
    }

    public static void main(String[] args) throws Exception {
//        System.out.println(new File("target/classes").getAbsolutePath());
        System.out.println("sizeOf(new Object())=" + sizeOf(new Object()));
        System.out.println("sizeOf(new A())=" + sizeOf(new A()));
        System.out.println("sizeOf(new B())=" + sizeOf(new B()));
        System.out.println("sizeOf(new B2())=" + sizeOf(new B2()));
        System.out.println("sizeOf(new B[3])=" + sizeOf(new B[3]));
        System.out.println("sizeOf(new C())=" + sizeOf(new C()));
        System.out.println("fullSizeOf(new C())=" + fullSizeOf(new C()));
        System.out.println("sizeOf(new D())=" + sizeOf(new D()));
        System.out.println("fullSizeOf(new D())=" + fullSizeOf(new D()));
        System.out.println("sizeOf(new int[3])=" + sizeOf(new int[3]));
        System.out.println("sizeOf(new Integer(101189192)=" + sizeOf(new Integer(101189192)));
        System.out.println("sizeOf(new Integer[0])=" + sizeOf(new Integer[0]));
        System.out.println("sizeOf(new Integer[1])=" + sizeOf(new Integer[1]));
        System.out.println("sizeOf(new Integer[2])=" + sizeOf(new Integer[2]));
        System.out.println("sizeOf(new Integer[3])=" + sizeOf(new Integer[3]));
        System.out.println("sizeOf(new Integer[4])=" + sizeOf(new Integer[4]));
        System.out.println("sizeOf(new A[3])=" + sizeOf(new A[3]));
        System.out.println("sizeOf(new E())=" + sizeOf(new E()));
        SimpleDateFormat simpleDateFormat =  new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("sizeOf(new SimpleDateFormat=" + fullSizeOf(simpleDateFormat));
        System.out.println("format:"+simpleDateFormat.format(new Date()));
        System.out.println("sizeOf(new SimpleDateFormat format=" + fullSizeOf(simpleDateFormat));
        try {
			System.out.println("parse:"+simpleDateFormat.parse("2018-07-09 18:24:30"));
		} catch (ParseException e) {
			e.printStackTrace();
		}
        System.out.println("sizeOf(new SimpleDateFormat parse=" + fullSizeOf(simpleDateFormat));
        
        DateFormatUtils dateFormatUtils = new DateFormatUtils();
        System.out.println("sizeOf(new dateFormatUtils parse=" + fullSizeOf(dateFormatUtils));
        
        System.out.println(dateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss"));
        System.out.println("sizeOf(new dateFormatUtils parse=" + fullSizeOf(dateFormatUtils));
        String[] tArray = new String[1];
        tArray[0] ="2018-07-09 18:24:30";
        DateUtils dateUtils = new DateUtils();
        System.out.println("sizeOf(new dateUtils parse=" + fullSizeOf(dateUtils));
        dateUtils.parseDate("2018-07-09 18:24:30", tArray);
        System.out.println("sizeOf(new dateUtils parse=" + fullSizeOf(dateUtils));
    }
}
<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com</groupId>
  <artifactId>testload</artifactId>
  <version>0.0.1-SNAPSHOT</version>

  <name>testload</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
    <java.rt>${java.home}/lib/rt.jar;${java.home}/lib/jce.jar</java.rt>
  </properties>

  <dependencies>
  	<dependency>
			<groupId>commons-logging</groupId>
			<artifactId>commons-logging</artifactId>
			<version>1.2</version>
		</dependency>
		<dependency>
			<groupId>commons-logging</groupId>
			<artifactId>commons-logging-api</artifactId>
			<version>1.1</version>
		</dependency>
		<dependency>
			<groupId>net.sf.json-lib</groupId>
			<artifactId>json-lib</artifactId>
			<version>2.4</version>
			<classifier>jdk15</classifier>
		</dependency>
		<dependency>
			<groupId>org.apache.sanselan</groupId>
			<artifactId>sanselan</artifactId>
			<version>0.97-incubator</version>
		</dependency>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
			<scope>test</scope>
		</dependency>
  </dependencies>
	<build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>
                    <encoding>utf-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.0.0</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <transformer
                                        implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <manifestEntries>
                                        <Premain-Class>com.atzy.tango.test.SizeOfObject</Premain-Class>
                                    </manifestEntries>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
	
</project>

 

程序员庖丁解牛
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 打印对象大小_如何获取一个Java对象所占内存大小
weixin_34619335的博客
02-13 5781
新建一个maven工程我们先在IDEA中新建一个名为ObjectSizeFetcherAgent的maven工程，如下图：在maven项目中的pom.xml中新增一个打jar包的插件，如下：org.apache.maven.pluginsmaven-compiler-plugin3.11.81.8/src/test/**utf-8org.apache.maven.pluginsmaven-jar-...
JAVA——对象所占内存空间大小的计算
sky_ground的博客
11-10 4003
学过c++的朋友想必对“c++的内存对齐规则”不会感到陌生。那么在java中，是否也存在这样的规则呢？为此，笔者进行了实验，发现java的内存对齐规则非常简明——8字节对齐。现与大家分享下。 一个java对象所占的内存空间分为三个部分：对象头（Mark Word+类型指针+长度）+实例数据+填充。 填充的目的是保证一个java对象的大小是8B的整数倍。 对象头分为三个部分：Mark Word、
java sizeof
05-31
分享一个java中的sizeof工具。非常好用。 下载后，导入这个jar包。然后在run as中配置VM参数如下： -javaagent:C:\\***存放路径***\\SizeOf.jar（DEF**盘都可以的哈）
java中的sizeof
达观.平和
01-02 864
     在C/C++中，当我们想知道一个对象或者一个原始数据类型所占用的内存大小时，只需简单调用sizeof操作符即可，但是，在java中是没有相应的操作符或者方法来直接完成相应功能的。sizeof 在C/C++得到大量的运用，是程序员必不可少的工具之一，那么为什么java却不提供呢？要回答这个问题，我们可以从另外一个角度来看，那就是为什么C/C++中要使用sizeof。C中要使用sizeof主...
java sizeof.jar_java.sizeOf
weixin_33268492的博客
02-13 263
IntroductionWith java.SizeOf you can measure the real memory size of your Java objects.The project is a little java agent what use the package java.lang.Instrument introduced in Java 5 and is released...
Java中的Sizeof
庖丁坊
08-24 1397
http://blog.csdn.net/chensheng913/archive/2004/08/24/83789.aspxhttp://blog.csdn.net/chensheng913/archive/2004/08/24/83794.aspx1.Java有类似于C语言中sizeof()的操作器吗？    表面答案是Java没有提供任何类似于C语言的sizeof()的操作器。但是，
java.sizeOf
weixin_34265814的博客
08-05 106
Introduction With java.SizeOf you can measure the real memory size of your Java objects. Download it here The project is a little java agent what use the package java.lang.Instrument introduced in J...
sizeof 计算出实例的大小
09-11
下面将详细解释如何利用反射来计算实例大小。 1. **Class对象和Field对象**：首先，我们需要获取类的`Class`对象，可以通过`Class.forName()`或者`instance.getClass()`来实现。然后，通过`getDeclaredFields()`...
java 通过sizeOf计算一个对象的大小
04-07
总的来说，通过`sizeOf`计算Java对象的大小是一项复杂的工作，涉及到JVM内部的内存管理和对象表示。尽管Java API没有直接提供这样的功能，但我们可以借助第三方库或自定义工具来实现。理解对象大小对于优化内存使用...
java-sizeof-0.0.4:一个查看java对象占用内存大小
最新发布
12-12
这个工具提供了查看对象实例大小的能力，这对于调试和性能优化非常有用。"java-sizeof-0.0.4"包含三个不同类型的JAR文件： 1. `java-sizeof-0.0.4-javadoc.jar`：这是Java文档的归档，包含了关于工具的API和方法的...
SizeOf.jar
11-02
一个SizeOf.jar.
sizeof4j:Java 的 sizeof
06-09
大小为4j 用于测量 Java 对象内存大小的 Java 库。 import com.arturmkrtchyan.sizeof4j.util.ConsoleUtil ; import static java.lang.System.out ; class Main { public static void main ( String [] args ) { ConsoleUtil . printJvmDetails(); out . println( " \n\n SizeOf " ); out . println( " ================================= " ); out . println( " -------------------------- " );
java SizeOf 对象的大小
03-24
NULL 博文链接：https://spice.iteye.com/blog/1104340
java中获取一个对象实例的大小工具
hu_youliang的博客
09-26 2041
pom.xml中引用： <!-- https://mvnrepository.com/artifact/com.carrotsearch/java-sizeof --> <dependency> <groupId>com.carrotsearch</groupId> <artifactId>java-sizeof</artifactId> <version>0.0.5</version>
java实现sizeof功能
vanadiumlin
03-11 202
java中模拟c中对sizeof的实现思路：利用java中GC内存回收前后的heap size差别，得出每个object的大小。 这是一个程序，java中没有现成的sizeof的实现，原因主要是java中的基本数据类型的大小都是固定的，所以看上去没有必要用sizeof这个关键字。实现的想法是这样的：java.lang.Runtime类中有一些简单的能涉及到内存管理的函数：Every Java...
Sizeof for Java
Just Do IT
07-05 1185
Q：java中有和C中的sizeof()相似的操作符吗？   A：简单的说java没有提供任何和C中sizeof()类似的操作符。但是我们可以分析一下为什么java程序常常需要他.     一个C程序员需要自己定义数据结构、分配内存，而sizeof()是知道内存块大小从而分配内存所必需的。另外，C内存分配器比如malloc()基本上不做任何事情,直到对象初始化时: programmer must
sizeof for java
juce的专栏
04-11 548
今天没事看精华区，发现去年有人讨论java的sizeof。结论好想是没什么好办法。 上面的地址先讨论了一下java中没有sizeof的必要，然后给了一段实现sizeof的代码。 In previous issues we've mentioned that Java(tm) has no sizeof() operator  like C/C++. With uniform siz
VC++实用技巧汇总：sizeof与编程实例
sizeof不是函数，而是运算符，它的作用是计算操作数在内存中的存储大小。它支持两种用法：一是直接应用于数据类型，如`sizeof(int)`；二是用于变量，如`sizeof(var_name)`，其中变量名可以省略括号。然而，sizeof不...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值