Java综合：讨论关于Java占用内存的研究(页 1) - 编程语言

不和人说话 发表于 2008-5-9 07:20

Java综合：讨论关于Java占用内存的研究

最近对程序占用内存方面做了一些优化，取得了不错的效果，总结了一些经验。
1X|N9Z9p.n:bP
简要说一下，相信会对大家写出优质的程序有所帮助。

下面的论述针对32位系统，对64位系统不适用，后叙经常你写了一个程序，一测试，功能没问题，一看内存占用也不多，就不去考虑其它的东西了。但可能程序使用了一个什么数据结构，会当数据规模变大时，内存占用激增。
S.h_C$c&_+Ugs
l.?*cf5KxA~*]gma
基本&&关键的问题是，Java里各种东东占多少内存？？？？？？？？？

E!gT pY/X
对于primitive类型，有8个
7j6A4W?+eMm+k$|
byte short int long float double char boolean 它们的长度分别是

1 2 4 8 4 8 2 1 8\Y"l(V s%z!XH

这个不罗嗦了，举例来说 "YXPg5H/m$t/Ii

long[] data=new long[1000]; :\(fAR Q:v
\AUr!I%q
占用内存 8*1000 bytes

此外，data本身是一个Object，也占用内存若干，后叙，当然它针对 8*1000来说，忽略不计

再说Object的占用，在说这个之前，先说说引用，一惯的说法是

Java里没有指针了，只有引用，引用是安全的
F2Pr#NK#bcx
S;G-^^{
这个说法没错，但是从机理上来说，引用就是指针，只是jvm对指针的使用检查和限制很多，这个引用/指针变得很安全
H1sY@@&U&s'Vu

直接来结论：一个引用占4byte ，在32位系统上

Object obj=null; //4byte

Object[] objs=new Object[1000]; //至少4*1000byte a,F+V&|)uZ/L_
4qsP5c9@

你看我定义了一个 obj，还是null，就占4byte 7B8~BjM0}"B5V

定义了一个 objs,1000个元素，但都是null啊，就都每个占4byte WheDE#`!@
&MF4|J{6sYL!t
是的！！！！！
%J2C@ kX
虽然obj==null，但它已经是一个引用，或者说一个指针了
RuM'_Fu
指针也要占地方啊！！！！啊！！！！啊！！！！ Pq*F9wiNTbP

接下来，直接给另一个结论： Object占8byte，注意，纯Object

0u;sH5d7QG;C9v
Object obj=new Object(); //多少？？？？ SV ?;I/p5L4m t?X

'sWPU R*N;a [!\k
8byte？？错！！ 12byte，忘了还有一个引用，8byte是Object的内容

记住 Object obj=new Object(); 占12byte
4\8j0G}(v7M][0I|

Object[] objs=new Object[1000];

for(int i=0;i<1000;i++) { 7X N)L6i7tqA i
4F:tv"Yl^
objs[i]=new Object(); )cm,[5Pc Fm0w

}

0Bpnw(Io `S5QP7WJ
至少占用 12*1000 bytes 1qe!n UG%je$JO

6Y4uSn"N&r
推论： Object占12bytes，似乎和上面的结论矛盾？？！！

没有！！不管Object，没有被垃圾回收之前，总得被别人引用吧？
@ b:l0s-pI"K6`}
总的有指针指它吧？既然指，那个引用or指针就要占地方啊 4byte

加起来是12byte，反正一个Object至少 12bytes

还是直接给结论，推导的过程我就都包办了，咱不是脏活累活抢着干么！！ SOV? }(O

一个Integer占 16 bytes

这时您可能会有疑问，Integer=Object+int，就是： !x,g d+gd@

public class Integer {

public int value; )d ?r,p/g5mu)R(e
WH_%_"B)XOj
}
R,ql?M@\a
Integer应该占 8+4=12 bytes啊

你说的有道理，但是jvm对所有的Object有限制！！

这个限制被我发现了，就是不管什么Object占的空间，要是8的倍数

12不是8的倍数，只能是16了！！！
~A(m?6} H2O!s9Xrt
@c;kk3v z Sx
推论：Byte也占16bytes!!!!!!!!!!!
-u WRiR"y

问：

Byte[] bytes=new Byte[1000]; {V|AK.Z(BD;p-R xp
CU.a"}G~2J3S
占用空间多少？
/CJ2j}bP]r-OdRv
答：约为（至少为） (16+4)*1000 bytes I;`4Y?!t:iH
[&UTCAt#ca
好家伙！！！！！！！！ 9vkY7NEv3m
B \n h0wP4[
6e0AA+I;q

论题：数组空间占用怎么算？

我这里直接给结论了，推导这个花了更长的时间：

对于数组来说，数组这个Object有一个length属性，数组的元素相当于其成员
hGF!@$H3q%RC1T(m
public class Array {

public int length;
'^.xm5P)w:@y
//... 其它成员

} z8x}NM'U

对于数组，我们不是直接可以取length属性么，源于此
2s5A4M%W#C'Ka%{F

public byte[] bytes=new byte[1000];
Bgy+i6x
System.out.println(bytes.length); // 看，有length属性
uU!NmL~
上面的bytes换算过来是：

public class Array {

public int length;

public byte byte0; |"n9H4SQ!v

public byte byte1;
$G[ Tf&g.y[
... %ItLm,}Y2vNr

public byte byte999;

}

上面的bytes占用的内存是： w!g.X"ZCH9Ei?c
8a._y:O Y
4+[8+4 + 1*1000] = 4+ [1012]=4+1016=1020 6U g$ba a

4是 bytes这个引用，8是Object基占的，4是length属性占的

1000是1000个成员占的，本来是 1012，但要求是8的倍数，变成 1016了
xYZ~llD
总共是 1020 yE6?-`,V x#]_K

再如：

byte[] bytes=new byte[4];
bP0T i&WRu?j$]
的内存占用是:

4+[8+4+4*1]=4+[16]=20;
8D QS_i;h4M)j6k

byte[] bytes=new byte[3]; 也是 20 ] @-VsHzd

对于元素是Object的数组，Object也是当作其成员，（注意只有引用这个数组的空间，这个可以推到普通Class上） B'q;tAD'~'ogP0Z{

Byte[] bytes=new Byte[1000];
*_l c;a/x2R%d
这个 bytes的定义相当于: *Ukbcn7I3QB.W[6C

public class Array { U7O%OD@%m

public int length;
K#fy/f"~#R8p)i'J
public Byte byte0; MOd8JCz\{

.....
?od3Uy9]Wx:D
public Byte byte999;
S C;I)Q#R#ufD9E
} NV ].A9\}D2xz,w+R

占用空间是：
.|}/sA8z8Ih+B#p
4+[8+4+4*1000]+16*1000= 4+ 4016 + 16000 = 你自己算吧 t(U2IwA

推论：千万不要用 Byte[] 有20倍的差距！！！！！！！ auZsY

a,^s:o"Jx
你可能一下子没明白过来，没关系多琢磨一下，对于普通的class来说 ,BL!D$gb?.t{@U;^Z
{U`!M@
，内容占用就是基加成员的占用，Object成员只记引用 5NJDgxEKP

public class Abc {
Q*n o*t$|t5N1x#e
public int n;
-d$Z)m@0Q.{gxqQ
public byte b; (w3JIxv

public Object obj;
1e {k{/?+\Y8m/ms,U
}
*D5nz;PBw
它的内容占用是： [8+4+1+4]=24

所以 Abc one=new Abc()的占用是 4+24=28
|*j{nf}a zV
提醒：对于 Abc的成员 obj没有计，如果要计入的话，循环这个过程就可以了。（琢磨一下）
-m7G1a-Y$N0D UU@
1UGA%kw y3c7Jl L
举例： 9o"vnu7@*MA1j

F&e.oroykG
public class Abc {
3i%j IqN"?f
public byte b;
l%X8^/{~|7x
public Object obj=null; &S#C3R&p4h#l Jl
-SX]{'D8Z]m
} :L{\h6B

public class Def { s_(A_Qce
|B-y&z5z;ON
public int n;

public byte b;
$YxT+b4yr ^
public Abc obj=new Abc(); H fy~Z2^7DB%?R4`
a%qT0B)M7C%N
}
?}I5T(FW([^w5v
问：
|,P?f(me
Def one=new Def(); //占多少？

不和人说话 发表于 2008-5-9 07:20

答：

4+[8+4+1+4]+[8+1+4]=4+24+16=44
?#|'br7XIp9gA+C
8y[8W O^#HP

public class Abc { @QH#dW1w
2u9S@c;oX0|[2T
public byte b; {*q(S6W`;b2k
u!ZP-y9@?O Uh
public Object obj=null; FS/B4d'MQ2C"x

}
\9{.N R?
q;P6O!R_R1e
public class Def {
.d:JJZE%J$L^
public int n;

public byte b;
zw%}tBqe \
public Abc[] objs=new Abc[100]; ,X1Qc`8ey#}
:Uv$LF+Fly@
{ A2\{n"Y

for(int i=0;i<10;i++) { ,@6Ib*ZN0I

objs[i]=new Abc();

}
+_R$aBxj
}

} m P6Y8}Ol0X*^U

问： ;lA/hD8b2\[c

Def one=new Def(); //占多少？
e_Dy8tha%Ss
答： Z [^cm7G

kao，一下我也算不出来，不过我写了程序，可以算出来，你给它一个Object，它就能递归的算出总共占了多少内存，这个程序不复杂，你也可以写出来。我等机会合适了再放出。 [`1r+ig6e

单独说一下String，String的结构是： 8ga9Ev!Y7i3sr
&W8h#d[e)DR0SPV FQ
public class String {

private final char value[];

private final int offset;
4R*p`3Uo:VBOC
private final int count;

private int hash; // Default to 0
$G7j9b#~*p
}

所以，不考虑那个char[]的占用，一个String最少占用 [8+4+4+4+4]=24bytes )b6e RO N]k6?-zS
.f[T3o9J
加上引用，共28bytes

所以 l4Q Ys De Hm

String s="";

占用28bytes！！！！！尽管它的长度为0
v0q9U}lV6\P\&^
如果精确的算，加上引用一个String的占用是

4+24+[8+4+2*length] vGo9bWM1E#f$Ho
2E{E8H;_ TaaUbmd
String s=""; 的占用是 28+16= 44
-K N2x7vhx q
String s="ab" 的占用是 28+16= 44

String s="abc" 的占用是 28+24 = 52
7_:ks%cF%I o \q {

要说的是，String是常用的类，这么看，String耗内存很多，所以jvm有优化，同样的内容尽量重用，所以除了28是必须的外，那个char[] 很可能一样
8Yn5V8I\uk,aR
比方说 f7A7V7|5EYm/f
c*d rqI BA
String[] s=new String[1000];
o4}&XZ,j8pT
for(int i=0;i<1000;i++) { b(R6G5n_v j'i5B
)W#N.agqd
s[i]=new String("abcdefasdjflksadjflkasdfj"); `9]-W!l2Uvn
.]$GhOqn$LF%M
}

的占用的数量级是 28*1000，那 1000个字符串本身基本上不占内存，只有一份！！！！！！
;u$u5V[:{W2[}
反正String 至少是 28,最多也可能是28！！！！！！！！
6mw:D{]f.G7}
uF ubQ!j;]K5z

比较占内存的数据结构，这个很重要：

基本上就是 primitive的包装 *?K)Cb/rI w@
doE:FTh

实例：

我以前用一个 F"j p5Y$X-E(oQ

Hashtable的结构，有100万个元素 @jux4{S+nRa

改为String[]＋int[]后，内存占用改观不少，速度也很快 #r4y6BBx+?
R+mci,_"xn
100万的String[] 快排一下，也就2秒多，查找用2分，和hash也差不多少。

紫月不追风 发表于 2008-5-9 20:28

不错，不错！

页: [1]

我爱电脑技术论坛's Archiver

Java综合：讨论关于Java占用内存的研究