计算 java_两种计算Java对象大小的方法objectFieldOffset

原文:http://blog.csdn.net/iter_zc/article/details/41822719

另一篇类似文章:http://www.cnblogs.com/magialmoon/p/3757767.html​

这篇说说如何计算Java

对象大小的方法。之前在聊聊高并发(四)Java对象的表示模型和运行时内存表示 这篇中已经说了Java对象的内存表示模型是Oop-Klass模型。

普通对象的结构如下,按64位机器的长度计算

1. 对象头(_mark), 8个字节

2. Oop指针,如果是32G内存以下的,默认开启对象指针压缩,4个字节

3. 数据区

4.Padding(内存对齐),按照8的倍数对齐

数组对象结构是

1. 对象头(_mark), 8个字节

2. Oop指针,如果是32G内存以下的,默认开启对象指针压缩,4个字节

3. 数组长度,4个字节

4. 数据区

5. Padding(内存对齐),按照8的倍数对齐

清楚了对象在内存的基本布局后,咱们说两种计算Java对象大小的方法

1. 通过直接获取对象的大小

2.

通过sun.misc.Unsafe对象的objectFieldOffset(field)等方法结合反射来计算对象的大小

的方式

先讲讲的方式,这种方法得到的是Shallow

Size,即遇到引用时,只计算引用的长度,不计算所引用的对象的实际大小。如果要计算所引用对象的实际大小,可以通过递归的方式去计算。

java.lang.instrument.Instrumentation的实例必须通过指定javaagent的方式才能获得,具体的步骤如下:

1. 定义一个类,提供一个premain方法: public static void premain(String

agentArgs, Instrumentation instP)

2. 创建META-INF/MANIFEST.MF文件,内容是指定PreMain的类是哪个: Premain-Class:

sizeof.ObjectShallowSize

3. 把这个类打成jar,然后用java -javaagent XXXX.jar XXX.main的方式执行

下面先定义一个类来获得java.lang.instrument.Instrumentation的实例,并提供了一个static的sizeOf方法对外提供Instrumentation的能力

[java] view plain

copy

packagesizeof;

import

java.lang.instrument.Instrumentation;

public

class

ObjectShallowSize {
private

static

Instrumentation inst;

public

static

void

premain(String agentArgs, Instrumentation instP){
inst = instP;

}

public

static

long

sizeOf(Object obj){
return

inst.getObjectSize(obj);

}

}

定义META-INF/MANIFEST.MF文件

[java]

view

plaincopy

Premain-Class: sizeof.ObjectShallowSize

打成jar包

[html]

view

plaincopy

cd 编译后的类和META-INF文件夹所在目录

jar cvfm java-agent-sizeof.jar META-INF/MANIFEST.MF  .

准备好了这个jar之后,我们可以写测试类来测试Instrumentation的getObjectSize方法了。在这之前我们先来看对象在内存中是按照什么顺序排列的

有如下这个类,字段的定义按如下顺序

[java]

view

plaincopy

private

static

class

ObjectA {
String str;  // 4

int

i1;

// 4

byte

b1;

// 1

byte

b2;

// 1

int

i2;

// 4

ObjectB obj; //4

byte

b3;

// 1

}

按照我们之前说的方法来计算一下这个对象所占大小,注意按8对齐

8(_mark) + 4(oop指针) + 4(str) + 4(i1) + 1(b1) + 1(b2) +

2(padding) + 4(i2) + 4(obj) + 1(b3) + 7(padding) = 40 ?

但事实上是这样的吗? 我们来用Instrumentation的getObjectSize来计算一下先:

[java]

view

plaincopy

package

test;

import

sizeof.ObjectShallowSize;

public

class

SizeofWithInstrumetation {
private

static

class

ObjectA {
String str;  // 4

int

i1;

// 4

byte

b1;

// 1

byte

b2;

// 1

int

i2;

// 4

ObjectB obj; //4

byte

b3;

// 1

}

private

static

class

ObjectB {
}

public

static

void

main(String[] args){
System.out.println(ObjectShallowSize.sizeOf(new

ObjectA()));

}

}

得到的结果是32!不是会按8对齐吗,b3之前的数据加起来已经是32了,多了1个b3,为33,应该对齐到40才对啊。事实上,HotSpot创建的对象的字段会先按照给定顺序排列一下,默认的顺序如下,从长到短排列,引用排最后

:  long/double --> int/float

-->  short/char -->

byte/boolean --> Reference

这个顺序可以使用JVM参数:

-XX:FieldsAllocationSylte=0(默认是1)来改变。

我们使用sun.misc.Unsafe对象的objectFieldOffset方法来验证一下:

[java]

view

plaincopy

Field[] fields = ObjectA.

class

.getDeclaredFields();

for

(Field f: fields){
System.out.println(f.getName() + " offset: "

+unsafe.objectFieldOffset(f));

}

可以看到确实是按照从长到短,引用排最后

的方式在内存中排列的。按照这种方法我们来重新计算下ObjectA创建的对象的长度:

8(_mark) + 4(oop指针) + 4(i1) + + 4(i2) + 1(b1) + 1(b2) + 1(b3) +

1(padding) +  4(str) + 4(obj) = 32

得到的结果和的结果是一样的,证明我们的计算方式是正确的。

sun.misc.Unsafe的方式

下面说一下通过sun.misc.Unsafe对象的objectFieldOffset(field)等方法结合反射来计算对象的大小。基本的思路如下:

1. 通过反射获得一个类的Field

2. 通过Unsafe的objectFieldOffset()获得每个Field的offSet

3. 对Field按照offset排序,取得最大的offset,然后加上这个field的长度,再加上Padding对齐

上面三步就可以获得一个对象的Shallow

size。可以进一步通过递归去计算所引用对象的大小,从而可以计算出一个对象所占用的实际大小。

如何获得Unsafe对象已经在这篇中聊聊序列化(二)使用sun.misc.Unsafe绕过new机制来创建Java对象

说过了,可以通过反射的机制来获得.

Oop指针是4还是未压缩的8也可以通过unsafe.arrayIndexScale(Object[].class)来获得,这个方法返回一个引用所占用的长度

[java]

view

plaincopy

static

{
try

{
Field field = Unsafe.class

.getDeclaredField(

"theUnsafe"

);

field.setAccessible(true

);

unsafe = (Unsafe) field.get(null

);

objectRefSize = unsafe.arrayIndexScale(Object[].class

);

} catch

(Exception e) {
throw

new

RuntimeException(e);

}

}

下面的源码摘自

http://java-performance.info/memory-introspection-using-sun-misc-unsafe-and-reflection/,

原文中的代码在计算对象大小的时候有问题,我做了微调,并加上了内存对齐的方法,这样计算出的结果和Instrumentation的getObjectSize方法是一样的。

[java]

view

plaincopy

package

test;

import

java.util.ArrayList;

import

java.util.Collections;

import

java.util.Comparator;

import

java.util.List;

public

class

ObjectInfo {
public

final

String name;

public

final

String type;

public

final

String contents;

public

final

int

offset;

public

final

int

length;

public

final

int

arrayBase;

public

final

int

arrayElementSize;

public

final

int

arraySize;

public

final

List children;

public

ObjectInfo(String name, String type, String contents,

int

offset,

int

length,

int

arraySize,

int

arrayBase,

int

arrayElementSize)

{
this

.name = name;

this

.type = type;

this

.contents = contents;

this

.offset = offset;

this

.length = length;

this

.arraySize = arraySize;

this

.arrayBase = arrayBase;

this

.arrayElementSize = arrayElementSize;

children = new

ArrayList(

1

);

}

public

void

addChild(

final

ObjectInfo info )

{
if

( info !=

null

)

children.add( info );

}

public

long

getDeepSize()

{
//return length + arraySize + getUnderlyingSize( arraySize != 0 );

return

addPaddingSize(arraySize + getUnderlyingSize( arraySize !=

0

));

}

long

size =

0

;

private

long

getUnderlyingSize(

final

boolean

isArray )

{
//long size = 0;

for

(

final

ObjectInfo child : children )

size += child.arraySize + child.getUnderlyingSize( child.arraySize != 0

);

if

( !isArray && !children.isEmpty() ){
int

tempSize = children.get( children.size() -

1

).offset + children.get( children.size() -

1

).length;

size += addPaddingSize(tempSize);

}

return

size;

}

private

static

final

class

OffsetComparator

implements

Comparator

{
@Override

public

int

compare(

final

ObjectInfo o1,

final

ObjectInfo o2 )

{
return

o1.offset - o2.offset;

//safe because offsets are small non-negative numbers

}

}

//sort all children by their offset

public

void

sort()

{
Collections.sort( children, new

OffsetComparator() );

}

@Override

public

String toString() {
final

StringBuilder sb =

new

StringBuilder();

toStringHelper( sb, 0

);

return

sb.toString();

}

private

void

toStringHelper(

final

StringBuilder sb,

final

int

depth )

{
depth( sb, depth ).append("name="

).append( name ).append(

", type="

).append( type )

.append( ", contents="

).append( contents ).append(

", offset="

).append( offset )

.append(", length="

).append( length );

if

( arraySize >

0

)

{
sb.append(", arrayBase="

).append( arrayBase );

sb.append(", arrayElemSize="

).append( arrayElementSize );

sb.append( ", arraySize="

).append( arraySize );

}

for

(

final

ObjectInfo child : children )

{
sb.append( '\n'

);

child.toStringHelper(sb, depth + 1

);

}

}

private

StringBuilder depth(

final

StringBuilder sb,

final

int

depth )

{
for

(

int

i =

0

; i 

sb.append( "\t"

);

return

sb;

}

private

long

addPaddingSize(

long

size){
if

(size %

8

!=

0

){
return

(size /

8

+

1

) *

8

;

}

return

size;

}

}

package

test;

import

java.lang.reflect.Array;

import

java.lang.reflect.Field;

import

java.lang.reflect.Modifier;

import

java.util.ArrayList;

import

java.util.Arrays;

import

java.util.Collections;

import

java.util.HashMap;

import

java.util.IdentityHashMap;

import

java.util.List;

import

java.util.Map;

import

sun.misc.Unsafe;

public

class

ClassIntrospector {
private

static

final

Unsafe unsafe;

private

static

final

int

objectRefSize;

static

{
try

{
Field field = Unsafe.class

.getDeclaredField(

"theUnsafe"

);

field.setAccessible(true

);

unsafe = (Unsafe) field.get(null

);

objectRefSize = unsafe.arrayIndexScale(Object[].class

);

} catch

(Exception e) {
throw

new

RuntimeException(e);

}

}

private

static

final

Map primitiveSizes;

static

{
primitiveSizes = new

HashMap(

10

);

primitiveSizes.put(byte

.

class

,

1

);

primitiveSizes.put(char

.

class

,

2

);

primitiveSizes.put(int

.

class

,

4

);

primitiveSizes.put(long

.

class

,

8

);

primitiveSizes.put(float

.

class

,

4

);

primitiveSizes.put(double

.

class

,

8

);

primitiveSizes.put(boolean

.

class

,

1

);

}

public

ObjectInfo introspect(

final

Object obj)

throws

IllegalAccessException {
try

{
return

introspect(obj,

null

);

} finally

{
// clean visited cache before returning in order to make

// this object reusable

m_visited.clear();

}

}

// we need to keep track of already visited objects in order to support

// cycles in the object graphs

private

IdentityHashMapm_visited =

new

IdentityHashMap(

100

);

private

ObjectInfo introspect(

final

Object obj,

final

Field fld)

throws

IllegalAccessException {
// use Field type only if the field contains null. In this case we will

// at least know what's expected to be

// stored in this field. Otherwise, if a field has interface type, we

// won't see what's really stored in it.

// Besides, we should be careful about primitives, because they are

// passed as boxed values in this method

// (first arg is object) - for them we should still rely on the field

// type.

boolean

isPrimitive = fld !=

null

&& fld.getType().isPrimitive();

boolean

isRecursive =

false

;

// will be set to true if we have already

// seen this object

if

(!isPrimitive) {
if

(m_visited.containsKey(obj))

isRecursive = true

;

m_visited.put(obj, true

);

}

final

Class type = (fld ==

null

|| (obj !=

null

&& !isPrimitive)) ? obj

.getClass() : fld.getType();

int

arraySize =

0

;

int

baseOffset =

0

;

int

indexScale =

0

;

if

(type.isArray() && obj !=

null

) {
baseOffset = unsafe.arrayBaseOffset(type);

indexScale = unsafe.arrayIndexScale(type);

arraySize = baseOffset + indexScale * Array.getLength(obj);

}

final

ObjectInfo root;

if

(fld ==

null

) {
root = new

ObjectInfo(

""

, type.getCanonicalName(), getContents(obj,

type), 0

, getShallowSize(type), arraySize, baseOffset,

indexScale);

} else

{
final

int

offset = (

int

) unsafe.objectFieldOffset(fld);

root = new

ObjectInfo(fld.getName(), type.getCanonicalName(),

getContents(obj, type), offset, getShallowSize(type),

arraySize, baseOffset, indexScale);

}

if

(!isRecursive && obj !=

null

) {
if

(isObjectArray(type)) {
// introspect object arrays

final

Object[] ar = (Object[]) obj;

for

(

final

Object item : ar)

if

(item !=

null

)

root.addChild(introspect(item, null

));

} else

{
for

(

final

Field field : getAllFields(type)) {
if

((field.getModifiers() & Modifier.STATIC) !=

0

) {
continue

;

}

field.setAccessible(true

);

root.addChild(introspect(field.get(obj), field));

}

}

}

root.sort(); // sort by offset

return

root;

}

// get all fields for this class, including all superclasses fields

private

static

List getAllFields(

final

Class type) {
if

(type.isPrimitive())

return

Collections.emptyList();

Class cur = type;

final

List res =

new

ArrayList(

10

);

while

(

true

) {
Collections.addAll(res, cur.getDeclaredFields());

if

(cur == Object.

class

)

break

;

cur = cur.getSuperclass();

}

return

res;

}

// check if it is an array of objects. I suspect there must be a more

// API-friendly way to make this check.

private

static

boolean

isObjectArray(

final

Class type) {
if

(!type.isArray())

return

false

;

if

(type ==

byte

[].

class

|| type ==

boolean

[].

class

|| type == char

[].

class

|| type ==

short

[].

class

|| type == int

[].

class

|| type ==

long

[].

class

|| type == float

[].

class

|| type ==

double

[].

class

)

return

false

;

return

true

;

}

// advanced toString logic

private

static

String getContents(

final

Object val,

final

Class type) {
if

(val ==

null

)

return

"null"

;

if

(type.isArray()) {
if

(type ==

byte

[].

class

)

return

Arrays.toString((

byte

[]) val);

else

if

(type ==

boolean

[].

class

)

return

Arrays.toString((

boolean

[]) val);

else

if

(type ==

char

[].

class

)

return

Arrays.toString((

char

[]) val);

else

if

(type ==

short

[].

class

)

return

Arrays.toString((

short

[]) val);

else

if

(type ==

int

[].

class

)

return

Arrays.toString((

int

[]) val);

else

if

(type ==

long

[].

class

)

return

Arrays.toString((

long

[]) val);

else

if

(type ==

float

[].

class

)

return

Arrays.toString((

float

[]) val);

else

if

(type ==

double

[].

class

)

return

Arrays.toString((

double

[]) val);

else

return

Arrays.toString((Object[]) val);

}

return

val.toString();

}

// obtain a shallow size of a field of given class (primitive or object

// reference size)

private

static

int

getShallowSize(

final

Class type) {
if

(type.isPrimitive()) {
final

Integer res = primitiveSizes.get(type);

return

res !=

null

? res :

0

;

} else

return

objectRefSize;

}

}

先一个测试

类来验证一下Unsafe的方式计算出的结果

[html]

view

plaincopy

public class ClassIntrospectorTest

{
public static void main(String[] args) throws IllegalAccessException {
final ClassIntrospector ci

=

new

ClassIntrospector();

ObjectInfo res;

res

=

ci

.introspect( new ObjectA() );

System.out.println( res.getDeepSize() );

}

private static class ObjectA {
String str;  // 4

int i1; // 4

byte b1; // 1

byte b2; // 1

int i2;  // 4

ObjectB obj; //4

byte b3;  // 1

}

private static class ObjectB {
}

}

计算结果如下:

32

和我们之前计算结果是一致的,证明是正确的。

最后再来测试一下数组对象的长度。有两个类如下:

[java]

view

plaincopy

private

static

class

ObjectC {
ObjectD[] array = new

ObjectD[

2

];

}

private

static

class

ObjectD {
int

value;

}

它们在内存的大体分布如下图:

我们可以手工计算一下ObjectC obj = new ObjectC()的大小:

ObjectC的Shallow size = 8(_mark) + 4(oop指针)  +

4(ObjectD[]引用) = 16

new ObjectD[2]数组的长度 =  8(_mark) + 4(oop指针) +

4(数组长度占4个字节) + 4(ObjectD[0]引用) + 4(ObjectD[1]引用) = 24

由于ObjectD[]数组没有指向具体的对象大小,所以我们手工计算的结果是16 + 24 = 40

使用Unsafe对象的方式来计算一下:

[java]

view

plaincopy

public

static

void

main(String[] args)

throws

IllegalAccessException {
final

ClassIntrospector ci =

new

ClassIntrospector();

ObjectInfo res;

res = ci.introspect( new

ObjectC() );

System.out.println( res.getDeepSize() );

}

计算结果如下,和我们计算的结果是一致的,证明是正确的:

40

再给ObjectD[]数组指向具体的ObjectD对象,再测试一下结果:

[java]

view

plaincopy

public

static

void

main(String[] args)

throws

IllegalAccessException {
final

ClassIntrospector ci =

new

ClassIntrospector();

ObjectInfo res;

res = ci.introspect( new

ObjectC() );

System.out.println( res.getDeepSize() );

}

private

static

class

ObjectC {
ObjectD[] array = new

ObjectD[

2

];

public

ObjectC(){
array[0

] =

new

ObjectD();

array[1

] =

new

ObjectD();

}

}

private

static

class

ObjectD {
int

value;

}

我们可以手工计算一下ObjectC obj = new ObjectC()的大小:

ObjectC的Shallow size = 8(_mark) + 4(oop指针)  +

4(ObjectD[]引用) = 16

new ObjectD[2]数组的长度 =  8(_mark) + 4(oop指针) +

4(数组长度占4个字节) + 4(ObjectD[0]引用) + 4(ObjectD[1]引用) = 24

ObjectD对象长度 = 8(_mark) + 4(oop指针) + 4(value) = 16

所以ObjectC实际占用的空间 = 16 + 24 + 2 * 16 = 72

使用Unsafe的方式计算的结果也是72,和我们手工计算的方式一致。

参考:  Memory

introspection using sun.misc.Unsafe and reflection
————————————————
版权声明:本文为CSDN博主「西从南来」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/weixin_30834169/article/details/114043010

已标记关键词 清除标记
相关推荐
DirectX修复工具(DirectX Repair)是一款系统级工具软件,简便易用。本程序为绿色版,无需安装,可直接运行。 本程序的主要功能是检测当前系统的DirectX状态,如果发现异常则进行修复。程序主要针对0xc000007b问题设计,可以完美修复该问题。本程序中包含了最新版的DirectX redist(Jun2010),并且全部DX文件都有Microsoft的数字签名,安全放心。 本程序为了应对一般电脑用户的使用,采用了易用的一键式设计,只要点击主界面上的“检测并修复”按钮,程序就会自动完成校验、检测、下载、修复以及注册的全部功能,无需用户的介入,大大降低了使用难度。在常规修复过程中,程序还会自动检测DirectX加速状态,在异常时给予用户相应提示。 本程序适用于多个操作系统,如Windows XP(需先安装.NET 2.0,详情请参阅“致Windows XP用户.txt”文件)、Windows Vista、Windows 7、Windows 8、Windows 8.1、Windows 8.1 Update、Windows 10,同时兼容32位操作系统和64位操作系统。本程序会根据系统的不同,自动调整任务模式,无需用户进行设置。 本程序的V4.0版分为标准版、增强版以及在线修复版。所有版本都支持修复DirectX的功能,而增强版则额外支持修复c++的功能。在线修复版功能与标准版相同,但其所需的数据包需要在修复时自动下载。各个版本之间,主程序完全相同,只是其配套使用的数据包不同。因此,标准版和在线修复版可以通过补全扩展包的形式成为增强版。本程序自V3.5版起,自带扩展功能。只要在主界面的“工具”菜单下打开“选项”对话框,找到“扩展”标签,点击其中的“开始扩展”按钮即可。扩展过程需要Internet连接,扩展成功后新的数据包可自动生效。扩展用时根据网络速度不同而不同,最快仅需数秒,最慢需要数分钟,烦请耐心等待。如扩展失败,可点击“扩展”界面左上角小锁图标切换为加密连接,即可很大程度上避免因防火墙或其他原因导致的连接失败。 本程序自V2.0版起采用全新的底层程序架构,使用了异步多线程编程技术,使得检测、下载、修复单独进行,互不干扰,快速如飞。新程序更改了自我校验方式,因此使用新版本的程序时不会再出现自我校验失败的错误;但并非取消自我校验,因此程序安全性与之前版本相同,并未降低。 程序有更新系统c++功能。由于绝大多数软件运行时需要c++的支持,并且c++的异常也会导致0xc000007b错误,因此程序在检测修复的同时,也会根据需要更新系统中的c++组件。自V3.2版本开始使用了全新的c++扩展包,可以大幅提高工业软件修复成功的概率。修复c++的功能仅限于增强版,标准版及在线修复版在系统c++异常时(非丢失时)会提示用户使用增强版进行修复。除常规修复外,新版程序还支持C++强力修复功能。当常规修复无效时,可以到本程序的选项界面内开启强力修复功能,可大幅提高修复成功率。请注意,请仅在常规修复无效时再使用此功能。 程序有两种窗口样式。正常模式即默认样式,适合绝大多数用户使用。另有一种简约模式,此时窗口将只显示最基本的内容,修复会自动进行,修复完成10秒钟后会自动退出。该窗口样式可以使修复工作变得更加简单快速,同时方便其他软件、游戏将本程序内嵌,即可进行无需人工参与的快速修复。开启简约模式的方法是:打开程序所在目录下的“Settings.ini”文件(如果没有可以自己创建),将其中的“FormStyle”一项的值改为“Simple”并保存即可。 新版程序支持命令行运行模式。在命令行中调用本程序,可以在路径后直接添加命令进行相应的设置。常见的命令有7类,分别是设置语言的命令、设置窗口模式的命令,设置安全级别的命令、开启强力修复的命令、设置c++修复模式的命令、控制Direct加速的命令、显示版权信息的命令。具体命令名称可以通过“/help”或“/?”进行查询。 程序有高级筛选功能,开启该功能后用户可以自主选择要修复的文件,避免了其他不必要的修复工作。同时,也支持通过文件进行辅助筛选,只要在程序目录下建立“Filter.dat”文件,其中的每一行写一个需要修复文件的序号即可。该功能仅针对高级用户使用,并且必须在正常窗口模式下才有效(简约模式时无效)。 本程序有自动记录日志功能,可以记录每一次检测修复结果,方便在出现问题时,及时分析和查找原因,以便找到解决办法。 程序的“选项”对话框中包含了7项高级功能。点击"常规”选项卡可以调整程序的基本运行情况,包括日志记录、安全级别控制、调试模式开启等。只有开启调试模式后才能在C
©️2020 CSDN 皮肤主题: 技术黑板 设计师:CSDN官方博客 返回首页