【转】哪个更快:Java堆还是本地内存
使用Java的一个好处就是你可以不用亲自来管理内存的分配和释放。当你用new
关键字来实例化一个对象时,它所需的内存会自动的在Java堆中分配。堆会被垃圾回收器进行管理,并且它会在对象超出作用域时进行内存回收。但是在JVM中有一个‘后门’可以让你访问不在堆中的本地内存(native memory)。在这篇文章中,我会给你演示一个对象是怎样以连续的字节码的方式在内存中进行存储,并且告诉你是应该怎样存储这些字节,是在Java堆中还是在本地内存中。最后我会就怎样从JVM中访问内存更快给一些结论:是用Java堆还是本地内存。
使用Unsafe
来分配和回收内存
sun.misc.Unsafe
可以让你在Java中分配和回收本地内存,就像C语言中的malloc
和free
。通过它分配的内存不在Java堆中,并且不受垃圾回收器的管理,因此在它被使用完的时候你需要自己来负责释放和回收。下面是我写的一个使用Unsafe
来管理本地内存的一个工具类:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
|
public class Direct implements Memory { private static Unsafe unsafe; private static boolean AVAILABLE = false ; static { try { Field field = Unsafe. class .getDeclaredField( "theUnsafe" ); field.setAccessible( true ); unsafe = (Unsafe)field.get( null ); AVAILABLE = true ; } catch (Exception e) { // NOOP: throw exception later when allocating memory } } public static boolean isAvailable() { return AVAILABLE; } private static Direct INSTANCE = null ; public static Memory getInstance() { if (INSTANCE == null ) { INSTANCE = new Direct(); } return INSTANCE; } private Direct() { } @Override public long alloc( long size) { if (!AVAILABLE) { throw new IllegalStateException( "sun.misc.Unsafe is not accessible!" ); } return unsafe.allocateMemory(size); } @Override public void free( long address) { unsafe.freeMemory(address); } @Override public final long getLong( long address) { return unsafe.getLong(address); } @Override public final void putLong( long address, long value) { unsafe.putLong(address, value); } @Override public final int getInt( long address) { return unsafe.getInt(address); } @Override public final void putInt( long address, int value) { unsafe.putInt(address, value); } } |
在本地内存中分配一个对象
让我们来将下面的Java对象放到本地内存中:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
public class SomeObject { private long someLong; private int someInt; public long getSomeLong() { return someLong; } public void setSomeLong( long someLong) { this .someLong = someLong; } public int getSomeInt() { return someInt; } public void setSomeInt( int someInt) { this .someInt = someInt; } } |
我们所做的仅仅是把对象的属性放入到Memory
中:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
public class SomeMemoryObject { private final static int someLong_OFFSET = 0 ; private final static int someInt_OFFSET = 8 ; private final static int SIZE = 8 + 4 ; // one long + one int private long address; private final Memory memory; public SomeMemoryObject(Memory memory) { this .memory = memory; this .address = memory.alloc(SIZE); } @Override public void finalize() { memory.free(address); } public final void setSomeLong( long someLong) { memory.putLong(address + someLong_OFFSET, someLong); } public final long getSomeLong() { return memory.getLong(address + someLong_OFFSET); } public final void setSomeInt( int someInt) { memory.putInt(address + someInt_OFFSET, someInt); } public final int getSomeInt() { return memory.getInt(address + someInt_OFFSET); } } |
现在我们来看看对两个数组的读写性能:其中一个含有数百万的SomeObject
对象,另外一个含有数百万的SomeMemoryObject
对象。
1
2
3
4
5
6
7
8
9
10
11
12
13
|
// with JIT: Number of Objects: 1 , 000 1 , 000 , 000 10 , 000 , 000 60 , 000 , 000 Heap Avg Write: 107 2.30 2.51 2.58 Native Avg Write: 305 6.65 5.94 5.26 Heap Avg Read: 61 0.31 0.28 0.28 Native Avg Read: 309 3.50 2.96 2.16 // without JIT: (-Xint) Number of Objects: 1 , 000 1 , 000 , 000 10 , 000 , 000 60 , 000 , 000 Heap Avg Write: 104 107 105 102 Native Avg Write: 292 293 300 297 Heap Avg Read: 59 63 60 58 Native Avg Read: 297 298 302 299 |
结论:跨越JVM的屏障来读本地内存大约会比直接读Java堆中的内存慢10倍,而对于写操作会慢大约2倍。但是需要注意的是,由于每一个SomeMemoryObject对象所管理的本地内存空间都是独立的,因此读写操作都不是连续的。那么我们接下来就来对比下读写连续的内存空间的性能。
访问一大块的连续内存空间
这个测试分别在堆中和一大块连续本地内存中包含了相同的测试数据。然后我们来做多次的读写操作看看哪个更快。并且我们会做一些随机地址的访问来对比结果。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
// with JIT and sequential access: Number of Objects: 1 , 000 1 , 000 , 000 1 , 000 , 000 , 000 Heap Avg Write: 12 0.34 0.35 Native Avg Write: 102 0.71 0.69 Heap Avg Read: 12 0.29 0.28 Native Avg Read: 110 0.32 0.32 // without JIT and sequential access: (-Xint) Number of Objects: 1 , 000 1 , 000 , 000 10 , 000 , 000 Heap Avg Write: 8 8 8 Native Avg Write: 91 92 94 Heap Avg Read: 10 10 10 Native Avg Read: 91 90 94 // with JIT and random access: Number of Objects: 1 , 000 1 , 000 , 000 1 , 000 , 000 , 000 Heap Avg Write: 61 1.01 1.12 Native Avg Write: 151 0.89 0.90 Heap Avg Read: 59 0.89 0.92 Native Avg Read: 156 0.78 0.84 // without JIT and random access: (-Xint) Number of Objects: 1 , 000 1 , 000 , 000 10 , 000 , 000 Heap Avg Write: 55 55 55 Native Avg Write: 141 142 140 Heap Avg Read: 55 55 55 Native Avg Read: 138 140 138 |
结论:在做连续访问的时候,Java堆内存通常都比本地内存要快。对于随机地址访问,堆内存仅仅比本地内存慢一点点,并且是针对大块连续数据的时候,而且没有慢很多。
最后的结论
在Java中使用本地内存有它的意义,比如当你要操作大块的数据时(>2G)并且不想使用垃圾回收器(GC)的时候。从延迟的角度来说,直接访问本地内存不会比访问Java堆快。这个结论其实是有道理的,因为跨越JVM屏障肯定是有开销的。这样的结论对使用本地还是堆的ByteBuffer
同样适用。使用本地ByteBuffer的速度提升不在于访问这些内存,而是它可以直接与操作系统提供的本地IO进行操作。
【转】哪个更快:Java堆还是本地内存的更多相关文章
- java堆转储与内存分析
jmap -dump:format=b,file=dumpfile.hprof pid 将进程的堆转储到dumpfile.hprof文件里 jmap -heap pid 查看堆内存占用情 ...
- 从几个sample来学习JAVA堆、方法区、JAVA栈和本地方法栈
最近在看<深入理解Java虚拟机>,书中给了几个例子,比较好的说明了几种OOM(OutOfMemory)产生的过程,大部分的程序员在写程序时不会太关注Java运行时数据区域的结构: 感觉有 ...
- 优化Java堆大小5温馨提示
总结:Java没有足够的堆大小可能会导致性能非常大的影响,这无疑将给予必要的程序,并不能带来麻烦.本文总结了影响Java居前五位的能力不足,并整齐地叠优化? 笔者Pierre有一个10高级系统架构师有 ...
- 优化Java堆大小的5个技巧
本文作者Pierre是一名有10多年经验的高级系统架构师,他的主要专业领域是Java EE.中间件和JVM技术.根据他多年的工作实践经验,他发现许多性能问题都是由Java堆容量不足和调优引起的.下面他 ...
- Java堆的理解
堆的核心概述 所有的对象实例以及数组都应当在运行时分配在堆上 从实际实用角度看 --"几乎所有的对象实例都在堆中分配内存" 数组和对象可能永远不会存储在栈上,因为栈帧中保存引用,这 ...
- 从sample来学习Java堆(转)
1)Java堆 所有对象的实例分配都在Java堆上分配内存,堆大小由-Xmx和-Xms来调节,sample如下所示: public class HeapOOM { static class OOMOb ...
- 性能监控工具以及java堆分析OOM
一.性能监控工具 1.系统性能监控 Linux -确定系统运行的整体状态,基本定位问题所在 -uptime: ------系统时间 ------运行时间(例子中为127天) ------连接数(每 ...
- Java堆内存溢出模拟
先了解一下Java堆: 关于Java内存区域的分配,可以查看Java运行时数据区域一篇文章. Java堆是虚拟机内存管理中最大的一块区域,该区域是线程共享的,某Java进程中所有的线程都可以访问该区域 ...
- 比XGBOOST更快--LightGBM介绍
xgboost的出现,让数据民工们告别了传统的机器学习算法们:RF.GBM.SVM.LASSO.........现在,微软推出了一个新的boosting框架,想要挑战xgboost的江湖地位.笔者尝试 ...
随机推荐
- openfire学习(一)
需要开发一款软件,其中的即时通讯功能使用xmpp协议来做,服务端用openfire. openfire的下载和配置就不多说,可能大多数人第一次用会遇到登陆不了的问题,我也遇到了,事实上登陆错误是因为用 ...
- mysql字符串的常用函数(截取和拼接)
#截取字符串(先正序取2个,再倒序取1个)SELECT SUBSTRING_INDEX(SUBSTRING_INDEX('aaa-gg-cc-dd','-',2),'-',-1) #获取子表某个字段的 ...
- HDU 1022 之 Train Problem I
Train Problem I Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)T ...
- 动态的添加ImageView到LinearLayout中并居中显示
ImageView imageView = new ImageView(mActivity); imageView.setImageResource(R.mipmap.gengduo); Linear ...
- php连接数据库步骤
第一步:连接数据库 $link=@mysql_connect('localhost','root','root') or die('数据库连接失败!'); echo '连接成功!'; 这里数据库连接函 ...
- 用python写windows服务
用python写windows服务(1) 以python2.5 为例需要软件 * python 2.5 * pywin32(与2.5 版本相匹配的) Service Control Ma ...
- wxPython学习笔记1
wxpython介绍: wxPython 是 Python 语言的一套优秀的 GUI 图形库,允许 Python 程序员很方便的创建完整的.功能键全的 GUI 用户界面. wxPython 是作为优 ...
- (链接)Tomcat设置Session的失效方式
tomcat 设置session过期时间(四种方式):https://blog.csdn.net/liuxiao723846/article/details/50055075 tomcat里设置ses ...
- 洛谷 - P1044 - 栈 - 简单dp
https://www.luogu.org/problemnew/show/P1044 由于是用标签搜索进来的,所以这道题一定是有dp的解法. 很显然规定每次加入元素之前可以从栈中清理出任意数量的元素 ...
- HDU5145:5145 ( NPY and girls ) (莫队算法+排列组合+逆元)
传送门 题意 给出n个数,m次访问,每次询问[L,R]的数有多少种排列 分析 \(n,m<=30000\),我们采用莫队算法,关键在于区间如何\(O(1)\)转移,由排列组合知识得到,如果加入一 ...