哪个更快：Java堆还是本地内存

 

驻马店ssl适用于网站、小程序/APP、API接口等需要进行数据传输应用场景，ssl证书未来市场广阔！成为创新互联公司的ssl证书销售渠道，可以享受市场价格4-6折优惠！如果有意向欢迎电话联系或者加微信：028-86922220（备注：SSL证书合作）期待与您的合作！

使用Java的一个好处就是你可以不用亲自来管理内存的分配和释放。当你用new关键字来实例化一个对象时，它所需的内存会自动的在Java堆中分配。堆会被垃圾回收器进行管理，并且它会在对象超出作用域时进行内存回收。但是在JVM中有一个‘后门’可以让你访问不在堆中的本地内存(native memory)。在这篇文章中，我会给你演示一个对象是怎样以连续的字节码的方式在内存中进行存储，并且告诉你是应该怎样存储这些字节，是在Java堆中还是在本地内存中。最后我会就怎样从JVM中访问内存更快给一些结论：是用Java堆还是本地内存。

使用Unsafe来分配和回收内存

sun.misc.Unsafe可以让你在Java中分配和回收本地内存，就像C语言中的malloc和free。通过它分配的内存不在Java堆中，并且不受垃圾回收器的管理，因此在它被使用完的时候你需要自己来负责释放和回收。下面是我写的一个使用Unsafe来管理本地内存的一个工具类：

 
 
    
  
  
  1. public class Direct implements Memory { 
    2. 
  
  
  2.  
    3. 
  
  
  3.     private static Unsafe unsafe; 
    4. 
  
  
  4.     private static boolean AVAILABLE = false; 
    5. 
  
  
  5.  
    6. 
  
  
  6.     static { 
    7. 
  
  
  7.         try { 
    8. 
  
  
  8.             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) { 
    9. 
  
  
  9.         unsafe.putInt(address, value); 
    10. 
  
  
  10.     } 
    11. 
  
  
  11. } 
    12.

在本地内存中分配一个对象

让我们来将下面的Java对象放到本地内存中：

 
 
    
  
  
  1. public class SomeObject { 
    2. 
  
  
  2.  
    3. 
  
  
  3.     private long someLong; 
    4. 
  
  
  4.     private int someInt; 
    5. 
  
  
  5.  
    6. 
  
  
  6.     public long getSomeLong() { 
    7. 
  
  
  7.         return someLong; 
    8. 
  
  
  8.     } 
    9. 
  
  
  9.     public void setSomeLong(long someLong) { 
    10. 
  
  
  10.         this.someLong = someLong; 
    11. 
  
  
  11.     } 
    12. 
  
  
  12.     public int getSomeInt() { 
    13. 
  
  
  13.         return someInt; 
    14. 
  
  
  14.     } 
    15. 
  
  
  15.     public void setSomeInt(int someInt) { 
    16. 
  
  
  16.         this.someInt = someInt; 
    17. 
  
  
  17.     } 
    18. 
  
  
  18. } 
    19.

我们所做的仅仅是把对象的属性放入到Memory中：

 
 
    
  
  
  1. public class SomeMemoryObject { 
    2. 
  
  
  2.  
    3. 
  
  
  3.     private final static int someLong_OFFSET = 0; 
    4. 
  
  
  4.     private final static int someInt_OFFSET = 8; 
    5. 
  
  
  5.     private final static int SIZE = 8 + 4; // one long + one int 
    6. 
  
  
  6.  
    7. 
  
  
  7.     private long address; 
    8. 
  
  
  8.     private final Memory memory; 
    9. 
  
  
  9.  
    10. 
  
  
  10.     public SomeMemoryObject(Memory memory) { 
    11. 
  
  
  11.         this.memory = memory; 
    12. 
  
  
  12.         this.address = memory.alloc(SIZE); 
    13. 
  
  
  13.     } 
    14. 
  
  
  14.  
    15. 
  
  
  15.     @Override 
    16. 
  
  
  16.     public void finalize() { 
    17. 
  
  
  17.         memory.free(address); 
    18. 
  
  
  18.     } 
    19. 
  
  
  19.  
    20. 
  
  
  20.     public final void setSomeLong(long someLong) { 
    21. 
  
  
  21.         memory.putLong(address + someLong_OFFSET, someLong); 
    22. 
  
  
  22.     } 
    23. 
  
  
  23.  
    24. 
  
  
  24.     public final long getSomeLong() { 
    25. 
  
  
  25.         return memory.getLong(address + someLong_OFFSET); 
    26. 
  
  
  26.     } 
    27. 
  
  
  27.  
    28. 
  
  
  28.     public final void setSomeInt(int someInt) { 
    29. 
  
  
  29.         memory.putInt(address + someInt_OFFSET, someInt); 
    30. 
  
  
  30.     } 
    31. 
  
  
  31.  
    32. 
  
  
  32.     public final int getSomeInt() { 
    33. 
  
  
  33.         return memory.getInt(address + someInt_OFFSET); 
    34. 
  
  
  34.     } 
    35. 
  
  
  35. } 
    36.

现在我们来看看对两个数组的读写性能：其中一个含有数百万的SomeObject对象，另外一个含有数百万的SomeMemoryObject对象。

// 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对象所管理的本地内存空间都是独立的，因此读写操作都不是连续的。那么我们接下来就来对比下读写连续的内存空间的性能。

访问一大块的连续内存空间

这个测试分别在堆中和一大块连续本地内存中包含了相同的测试数据。然后我们来做多次的读写操作看看哪个更快。并且我们会做一些随机地址的访问来对比结果。

// 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堆还是本地内存
转载来源：http://www.mswzjz.com/qtweb/news46/173996.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

静态网站知识

同城分类信息

芦山网站建设　　 　app软件开发公司　　 　重庆移动机房托管　　 　梓潼网站设计　　 　成都网站改版　　 　移动手机网站制作　　 　seo优化　　 　营销型网站建设　　 　邛崃做网站　　 　攀枝花网站建设　　 　网站建设报价方案　　 　成都防护栏　　 　雨棚定制　　 　腾讯免备案主机　　 　app开发　　 　关键词排名优化　　 　成都app开发公司　　 　乐山服务器托管　　 　成都雨棚定制　　 　南充服务器托管