【翻译】JAVA堆和原生内存谁更快?

转至http://my.oschina.net/u/203607/blog/215765

这篇文章从两个测试去比较了JAVA堆和原生内存的读写操作。译文出处：http://lipspace.duapp.com原文出处：http://mentablog.soliveirajr.com/2012/11/which-one-is-faster-java-heap-or-native-memory/

目录[-]

• 使用Unsafe去分配和释放
• 把一个对象存储在原生内存
• 访问连续的大块内存
• 最后结论

这是我的第一篇翻译的比较完整的博文，若有错处请指出。这篇文章从两个测试去比较了JAVA堆和原生内存的读写操作。
译文出处：http://lipspace.duapp.com

原文出处：http://mentablog.soliveirajr.com/2012/11/which-one-is-faster-java-heap-or-native-memory/

JAVA语言有一个优点就是你不需要去处理内存的分配和释放。当你使用new关键字去实例化一个对象的时候，必要的内存就会分配到JVM堆里面。这个堆是由垃圾回收器管理着，当这个对象没有被引用的时候它的内存就会被回收掉。但是这里还是有一个后门可以直接通过JVM访问原生内存。在这篇文章里我将会展示一下如何把一个对象作为一个字节序列存储在内存里，并且讲讲你该选择堆还是直接内存（即原生内存）去保存这些字节。最后我会总结一下在JVM里面去读取堆内存还是直接内存更快。

使用Unsafe去分配和释放

sun.misc.Unsafe 类允许你像在C里面调用malloc 和free 那样在JAVA里面去分配和释放原生内存。你创建的内存将会脱离堆并且不再受到垃圾回收器的管理，也就是说这部分内存在使用完之后的释放就是你的责任了。下面我的Direct类展示如何使用unsafe类。

01	public classDirect implements Memory {

02

03	privatestatic Unsafe unsafe;

04	privatestatic boolean AVAILABLE = false;

05

06

static{

07

try{

08	Field field = Unsafe.class.getDeclaredField("theUnsafe");

09	field.setAccessible(true);

10	unsafe = (Unsafe)field.get(null);

11	AVAILABLE =true;

12	}catch(Exception e) {

13	// NOOP: throw exception later when allocating memory

14

}

15

}

16

17	publicstatic boolean isAvailable() {

18	returnAVAILABLE;

19

}

20

21	privatestatic Direct INSTANCE = null;

22

23	publicstatic Memory getInstance() {

24	if(INSTANCE == null) {

25	INSTANCE =new Direct();

26

}

27	returnINSTANCE;

28

}

29

30	privateDirect() {

31

32

}

33

34

@Override

35	publiclong alloc(longsize) {

36	if(!AVAILABLE) {

37	thrownew IllegalStateException("sun.misc.Unsafe is not accessible!");

38

}

39	returnunsafe.allocateMemory(size);

40

}

41

42

@Override

43	publicvoid free(longaddress) {

44	unsafe.freeMemory(address);

45

}

46

47

@Override

48	publicfinal long getLong(long address) {

49	returnunsafe.getLong(address);

50

}

51

52

@Override

53	publicfinal void putLong(long address, long value) {

54	unsafe.putLong(address, value);

55

}

56

57

@Override

58	publicfinal int getInt(long address) {

59	returnunsafe.getInt(address);

60

}

61

62

@Override

63	publicfinal void putInt(long address, int value) {

64	unsafe.putInt(address, value);

65

}

66

67

@Override

68	publicfinal void putByte(long address, byte value) {

69	unsafe.putByte(address, value);

70

}

71

72

@Override

73	publicfinal byte getByte(long address) {

74	returnunsafe.getByte(address);

75

}

76

}

把一个对象存储在原生内存

等一下我们就会将下面的一个JAVA对象存储到原生内存里面：

01	public classSomeObject {

02

03	privatelong someLong;

04	privateint someInt;

05

06	publiclong getSomeLong() {

07	returnsomeLong;

08

}

09	publicvoid setSomeLong(longsomeLong) {

10	this.someLong = someLong;

11

}

12	publicint getSomeInt() {

13	returnsomeInt;

14

}

15	publicvoid setSomeInt(intsomeInt) {

16	this.someInt = someInt;

17

}

18

}

注意我们下面做的是为了能够在 内存 里面存储它的属性：

01	public classSomeMemoryObject {

02

03	privatefinal static int someLong_OFFSET = 0;

04	privatefinal static int someInt_OFFSET = 8;

05	privatefinal static int SIZE = 8 + 4; // one long + one int

06

07	privatelong address;

08	privatefinal Memory memory;

09

10	publicSomeMemoryObject(Memory memory) {

11	this.memory = memory;

12	this.address = memory.alloc(SIZE);

13

}

14

15

@Override

16	publicvoid finalize() {

17	memory.free(address);

18

}

19

20	publicfinal void setSomeLong(long someLong) {

21	memory.putLong(address + someLong_OFFSET, someLong);

22

}

23

24	publicfinal long getSomeLong() {

25	returnmemory.getLong(address + someLong_OFFSET);

26

}

27

28	publicfinal void setSomeInt(int someInt) {

29	memory.putInt(address + someInt_OFFSET, someInt);

30

}

31

32	publicfinal int getSomeInt() {

33	returnmemory.getInt(address + someInt_OFFSET);

34

}

35

}

现在我们来为两个数组进行标准的读写访问操作：一个数组有成千上百万个SomeObjects ，另一个有成千上百万个SomeMemoryObjects。完整的代码可以在这里看到，输出结果如下：

// 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去直接访问原生内存读取大约要慢上十倍，写入的话大约要慢两倍。但是注意每一个SomeMemoryObject都是分配了它自己的原生内存空间，所以读取和写入都是不连续的，也就是说，每一个直接内存对象读写的来源和去往它自己的分配内存空间都是有可能在任何地方的。接下来我们继续利用标准的读写访问操作去确定一下连续的直接内存和堆内存哪个更快。

访问连续的大块内存

这个测试包括了在堆内存里面分配一个byte数组和在原生内存里面对应分配一个chunk，两者存储的数据量是相同的。然后我们连续的写入和读取几次来看看哪一个更快。同时我们也测试了随机访问数组里面任何一个位置去比较一下结果。连续块测试代码在这里，随机测试代码在这里。结果如下：

// 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

结论：在连续块访问里，堆内存总是比直接内存要快。在随机访问里，堆内存比大的chunks存储要慢上一点，不是很多。

最后结论

在JAVA里面使用原生内存有着一定的用途，例如当你想要操作大量的数据（>2 gigabytes）或者当你想脱离垃圾回收机制的时候。然而，在上面做的测试可以看到，通过JVM里面访问直接内存是不比访问堆内存快的。这个结果是有道理的，因为在穿过JVM的时候是有一定的消耗的，不论是在使用堆的ByteBuffer还是使用直接内存的都是有相同的问题。而直接内存 ByteBuffer 的速度优势并不是指访问的速度优势，而是指直接和操作系统原生I/O操作的直接会话能力优势。另一个不错的讨论在 Peter Lawrey 的博客里面是关于随着工作时间序列的推移内存映射文件的使用( the use of memory-mapped files when working with time-series.)，大家可以看看。

[1] 更多避免 GC 的方法可以看作者之前的一篇文章 Real-time programming without the GC.