Java内存分析(转载)

源地址：http://tech.ccidnet.com/art/3539/20080508/1443759_1.html
最近对程序占用内存方面做了一些优化，取得了不错的效果，总结了一些经验。
简要说一下，相信会对大家写出优质的程序有所帮助。

下面的论述针对32位系统，对64位系统不适用，后叙经常你写了一个程序，一测试，功能没问题，一看内存占用也不多，就不去考虑其它的东西了。但可能程序使用了一个什么数据结构，会当数据规模变大时，内存占用激增。
 

基本&&关键的问题是，Java里各种东东占多少内存？？？？？？？？？
 
对于primitive类型，有8个
byte short int long float double char
boolean 它们的长度分别是
1 2 4 8 4 8 2 1
这个不罗嗦了，举例来说
long[] data=new long[1000];
占用内存 8*1000 bytes
此外，data本身是一个Object，也占用内存若干，后叙，当然它针对
8*1000来说，忽略不计
 
再说Object的占用，在说这个之前，先说说引用，一惯的说法是
Java里没有指针了，只有引用，引用是安全的
 

这个说法没错，但是从机理上来说，引用就是指针，只是jvm对指针的使用检查和限制很多，这个引用/指针变得很安全
 
直接来结论：一个引用占4byte ，在32位系统上
 
Object obj=null; //4byte
Object[] objs=new Object[1000];
//至少4*1000byte
 
你看我定义了一个 obj，还是null，就占4byte
定义了一个
objs,1000个元素，但都是null啊，就都每个占4byte
是的！！！！！
虽然obj==null，但它已经是一个引用，或者说一个指针了
指针也要占地方啊！！！！啊！！！！啊！！！！
 
接下来，直接给另一个结论：
Object占8byte，注意，纯Object
 
Object obj=new Object(); //多少？？？？
 
8byte？？ 错！！
12byte，忘了还有一个引用，8byte是Object的内容
记住 Object obj=new Object(); 占12byte
 
Object[] objs=new Object[1000];
for(int i=0;i<1000;i++) {
objs[i]=new Object();
}
 
至少占用 12*1000 bytes
 
推论： Object占12bytes，似乎和上面的结论矛盾？？！！
没有！！不管Object，没有被垃圾回收之前，总得被别人引用吧？
总的有指针指它吧？既然指，那个引用or指针就要占地方啊 4byte
加起来是12byte，反正一个Object至少 12bytes
 
还是直接给结论，推导的过程我就都包办了，咱不是脏活累活抢着干么！！
一个Integer占 16 bytes
 
这时您可能会有疑问，Integer=Object+int，就是：
public class Integer {
public int value;
}
Integer应该占 8+4=12 bytes啊
你说的有道理，但是jvm对所有的Object有限制！！
这个限制被我发现了，就是不管什么Object占的空间，要是8的倍数
12不是8的倍数，只能是16了！！！
 
推论：Byte也占16bytes!!!!!!!!!!!
 
问：
Byte[] bytes=new Byte[1000];
占用空间多少？
答： 约为（至少为） (16+4)*1000 bytes
好家伙！！！！！！！！
 
 
论题：数组空间占用怎么算？
我这里直接给结论了，推导这个花了更长的时间：

对于数组来说，数组这个Object有一个length属性，数组的元素相当于其成员
public class Array {
public int length;
//... 其它成员
}
对于数组，我们不是直接可以取length属性么，源于此
 
public byte[] bytes=new byte[1000];
System.out.println(bytes.length); //
看，有length属性
上面的bytes换算过来是：
public class Array {
public int length;
public byte byte0;
public byte byte1;
...
public byte byte999;
}
上面的bytes占用的内存是：
4+[8+4 + 1*1000] = 4+
[1012]=4+1016=1020
4是
bytes这个引用，8是Object基占的，4是length属性占的
1000是1000个成员占的，本来是 1012，但要求是8的倍数，变成
1016了
总共是 1020
再如：
byte[] bytes=new byte[4];
的内存占用是:
4+[8+4+4*1]=4+[16]=20;
 
byte[] bytes=new byte[3]; 也是 20
 

对于元素是Object的数组，Object也是当作其成员，（注意只有引用这个数组的空间，这个可以推到普通Class上）
 
Byte[] bytes=new Byte[1000];
这个 bytes的定义相当于:
public class Array {
public int length;
public Byte byte0;
.....
public Byte byte999;
}
占用空间是：
4+[8+4+4*1000]+16*1000= 4+ 4016 + 16000
= 你自己算吧
 
推论：千万不要用 Byte[] 有20倍的差距！！！！！！！
 
 
你可能一下子没明白过来，没关系多琢磨一下，对于普通的class来说
，内容占用就是基加成员的占用，Object成员只记引用
public class Abc {
public int n;
public byte b;
public Object obj;
}
它的内容占用是： [8+4+1+4]=24
所以 Abc one=new Abc()的占用是 4+24=28
提醒：对于 Abc的成员
obj没有计，如果要计入的话，循环这个过程就可以了。（琢磨一下）
 
举例：
 
public class Abc {
public byte b;
public Object obj=null;
}
 
public class Def {
public int n;
public byte b;
public Abc obj=new Abc();
}
问：
Def one=new Def(); //占多少？
答：
4+[8+4+1+4]+[8+1+4]=4+24+16=44
 
 
public class Abc {
public byte b;
public Object obj=null;
}
 
public class Def {
public int n;
public byte b;
public Abc[] objs=new Abc[100];
{
for(int i=0;i<10;i++) {
objs[i]=new Abc();
}
}
}
问：
Def one=new Def(); //占多少？
答：

kao，一下我也算不出来，不过我写了程序，可以算出来，你给它一个Object，它就能递归的算出总共占了多少内存，这个程序不复杂，你也可以写出来。我等机会合适了再放出。
 
单独说一下String，String的结构是：
public class String {
private final char value[];
private final int offset;
private final int count;
private int hash; // Default to 0
}
所以，不考虑那个char[]的占用，一个String最少占用
[8+4+4+4+4]=24bytes
加上引用，共28bytes
所以
String s="";
占用28bytes！！！！！尽管它的长度为0
如果精确的算，加上引用一个String的占用是
4+24+[8+4+2*length]
String s=""; 的占用是 28+16= 44
String s="ab" 的占用是 28+16= 44
String s="abc" 的占用是 28+24 = 52
 

要说的是，String是常用的类，这么看，String耗内存很多，所以jvm有优化，同样的内容尽量重用，所以除了28是必须的外，那个char[]
很可能一样
比方说
String[] s=new String[1000];
for(int i=0;i<1000;i++) {
s[i]=new
String("abcdefasdjflksadjflkasdfj");
}
的占用的数量级是 28*1000，那
1000个字符串本身基本上不占内存，只有一份！！！！！！
反正String 至少是 28,最多也可能是28！！！！！！！！
 
 
比较占内存的数据结构，这个很重要：
基本上就是 primitive的包装
 
实例：
我以前用一个
Hashtable的结构，有100万个元素
改为String[]＋int[]后，内存占用改观不少，速度也很快
100万的String[]
快排一下，也就2秒多，查找用2分，和hash也差不多少。



转发至微博
 



转发至微博

阅读(15)|
评论(0)

|
       



用微信  “扫一扫”

将文章分享到朋友圈。

 



用易信  “扫一扫”

将文章分享到朋友圈。

 

喜欢
推荐 0人  | 
转载

 

历史上的今天

最近读者

热度

在LOFTER的更多文章

关闭

玩LOFTER，免费冲印20张照片，人人有奖！     我要抢>

评论

this.p={ m:2,
b:2,
loftPermalink:'',
id:'fks_087065092083085069092087084067072084080068086081080065084095',
blogTitle:'黑马程序员--Java内存分析（转）',
blogAbstract:'
源地址：http://tech.ccidnet.com/art/3539/20080508/1443759_1.html\r\n

最近对程序占用内存方面做了一些优化，取得了不错的效果，总结了一些经验。 \r\n

简要说一下，相信会对大家写出优质的程序有所帮助。 \r\n

下面的论述针对32位系统，对64位系统不适用，后叙经常你写了一个程序，一测试，功能没问题，一看内存占用也不多，就不去考虑其它的东西了。但可能程序使用了一个什么数据结构，会当数据规模变大时，内存占用激增。
\r\n

\r\n

基本&&关键的问题是，Java里各种东东占多少内存？？？？？？？？？
\r\n

', blogTag:'', blogUrl:'blog/static/21727620920134802732102',
isPublished:1, istop:false, type:0, modifyTime:1400160336232,
publishTime:1367987252102,
permalink:'blog/static/21727620920134802732102', commentCount:0,
mainCommentCount:0, recommendCount:0, bsrk:-100, publisherId:0,
recomBlogHome:false, currentRecomBlog:false, attachmentsFileIds:[],
vote:{}, groupInfo:{}, friendstatus:'none',
followstatus:'unFollow', pubSucc:'', visitorProvince:'',
visitorCity:'', visitorNewUser:false, postAddInfo:{}, mset:'000',
mcon:'', srk:-100, remindgoodnightblog:false, isBlackVisitor:false,
isShowYodaoAd:false,
hostIntro:'JAVA软件工程师,有扎实的Java基础,熟悉JavaEE技术,对框架的底层原理熟悉,学习能力强。',
hmcon:'0', selfRecomBlogCount:'0', lofter_single:'' }

{list a as x}
{if !!x}
{if x.visitorName==visitor.userName} {else} {/if}
{if x.moveFrom=='wap'}   {elseif
x.moveFrom=='iphone'}