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

暗月项目七详解 本文围绕“暗月靶场项目七”展开,记录了一次从外网 Web 入口逐步深入内网并最终获取域控目标的完整实训过程。 阅读详情

点击上方“芋道源码”,选择“置顶公众号”

技术文章第一时间送达!

源码精品专栏

 

译文出处: shenzhang   原文出处:原文链接

使用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进行操作。



如果你对 Dubbo 感兴趣,欢迎加入我的知识星球一起交流。


知识星球

目前在知识星球(https://t.zsxq.com/2VbiaEu)更新了如下 Dubbo 源码解析如下:

01. 调试环境搭建
02. 项目结构一览
03. 配置 Configuration
04. 核心流程一览

05. 拓展机制 SPI

06. 线程池

07. 服务暴露 Export

08. 服务引用 Refer

09. 注册中心 Registry

10. 动态编译 Compile

11. 动态代理 Proxy

12. 服务调用 Invoke

13. 调用特性 

14. 过滤器 Filter

15. NIO 服务器

16. P2P 服务器

17. HTTP 服务器

18. 序列化 Serialization

19. 集群容错 Cluster

20. 优雅停机

21. 日志适配

22. 状态检查

23. 监控中心 Monitor

24. 管理中心 Admin

25. 运维命令 QOS

26. 链路追踪 Tracing

...
一共 60 篇++

源码不易↓↓↓↓↓

点赞支持老艿艿↓↓

C# MES通信从入门到精通(1)——串口传输文件 本文详细介绍了在Mes通信领域如何使用串口发送文件,由实战经验总结,堪称MES通信领域的葵花宝典! 阅读详情

相关推荐

避开这些坑!RK3588安卓系统内置输入法的正确姿势(含.mk文件修改指南)

本文详细解析了在RK3588安卓系统定制中预置第三方输入法的完整流程与关键避坑指南。重点涵盖APK签名、Android.mk文件编写、系统默认输入法配置(使用adb ime list命令获取服务名)以及SeLinux策略适配等核心步骤,并指出RK3566/RK3568等兄弟平台的通用性与差异点,帮助开发者实现稳定、深度的系统集成。

tgb34567890的博客 440

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

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

860MHz的专栏 978

unity中判断是否联网,判断网络状态的两种方式

unity中判断是否联网,判断网络状态的两种方式

wla2996gpy032的博客 1879

堆(概念,数据结构中堆与内存堆区的区别 ,堆的基本操作)

堆的特性: 必须是完全二叉树 用数组实现 任一结点的值是其子树所有结点的最大值或最小值 最大值时,称为“最大堆”,也称大根堆; 最小值时,称为“最小堆”,也称小根堆。 大根堆 小根堆 可以看到,对于**堆(Heap)**这种数据结构,从根节点到任意结点路径上所有的结点都是有序的。 数据结构中堆与内存堆区的区别 一、数据结构中的堆和栈 堆和栈在数据结构中是两种不同的数据结构。 两者都是数据...

LXY的博客 2万+

Cursor AI编程工具保姆级安装指南:从下载到中文界面设置(含免费额度说明)

本文提供Cursor AI编程工具的保姆级安装与设置教程。详细指导从官网下载、安装到中文界面切换的每一步,并重点说明其每月500次高级模型调用的免费额度策略。通过个性化设置与核心插件推荐,帮助开发者快速上手,提升AI辅助编程效率。

weixin_29191761的博客 675

基于FPGA的ov5640摄像头简易图像采集装置详解

本文介绍一种基于FPGA的,通过流模式DDR实现OV5640摄像头数据采集并显示的方法。

qq_42230252的博客 1万+

CMOS开关参数提取实战:从BSIM模型到RC等效网络的完整流程

本文提供了一套完整的CMOS开关参数提取实战流程,指导射频工程师如何将复杂的BSIM模型简化为直观的电阻-电容(RC)等效网络。文章详细阐述了从仿真环境设置、导通与关断状态下的RC参数提取,到模型验证与性能评估的每一步,旨在帮助工程师深入理解器件本质,为电路优化和版图协同设计提供关键依据。

e4f5g6h的博客 385

通过JLink下载实现工控MCU批量烧录实战案例

利用JLink下载工具实现高效稳定的工控MCU批量烧录,提升产线效率。案例详细解析了脚本配置与自动化流程,突出jlink下载的可靠性和可扩展性,适用于大规模嵌入式部署场景。

weixin_30205153的博客 816

java 本地内存_哪个更快:Java堆还是本地内存

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

weixin_30269407的博客 276

无迹卡尔曼滤波 (UKF, Unscented Kalman Filter) 算法详解及案例分析

无迹卡尔曼滤波是一种用于估计非线性系统状态的递归算法。其目标是通过结合系统模型和观测数据,估计系统的最优状态。

闲人编程的博客 2632

华为od 面试八股文_C++_01_含答案

华为od 面试八股文_C++_01_含答案

MISAYAONE的博客 5603

java哪块内存访问速度最快_哪个更快:Java堆还是本地内存

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

weixin_39751871的博客 370

传导案例:某医疗仪器传导骚扰整改案例

紫外线光疗仪是一种专业的医疗设备,主要用于治疗银屑病、白癜风等皮肤疾病。该设备采用物理治疗技术,通过特定波长的紫外线照射人体来达到治疗效果。自1984年窄谱中波紫外线(NB-UVB)应用于临床以来,该技术已成为治疗早期蕈样肉芽肿(MF)的有效方法之一。作为二类医疗器械,紫外线光疗仪必须符合严格的电磁兼容性(EMC)标准,这不仅关系到设备自身的稳定运行,更关乎患者的使用安全和治疗效果。紫外线光疗仪传导骚扰整改案例充分展示了系统性EMC设计的重要性。

m0_56451176的博客 340

java 本地内存_院长告诉你Java堆和本地内存到底哪个更快!(转载)

原文出处:http://blog.youkuaiyun.com/u011277123/article/details/53282444使用Java的一个好处就是你可以不用亲自来管理内存的分配和释放。当你用new关键字来实例化一个对象时,它所需的内存会自动的在Java堆中分配。堆会被垃圾回收器进行管理,并且它会在对象超出作用域时进行内存回收。但是在JVM中有一个‘后门’可以让你访问不在堆中的本地内存(nativ...

weixin_39809175的博客 196

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

java堆和内存的区别,哪个更快?

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

androidstar_cn的博客 350

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

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

这是我的第一篇翻译的比较完整的博文,若有错处请指出。这篇文章从两个测试去比较了JAVA堆和原生内存的读写操作。译文出处:http://lipspace.duapp.comJAVA语言有一个优点就是你不需要去处理内存的分配和释放。当你使用new关键字去实例化一个对象的时候,必要的内存就会分配到JVM堆里面。这个堆是由垃圾回收器管理着,当这个对象没有被引用的时候它的内存就会被回收掉。但是这里还是有一个...

weixin_30404433的博客 266

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

Java堆介绍

对于Java应用程序来说,Java堆(Java Heap)是虚拟机所管理的内存中最大的一块。Java堆是被所 有线程共享的一块内存区域,在虚拟机启动时创建。此内存区域的唯一目的就是存放对象实例,Java 世界里“几乎”所有的对象实例都在这里分配内存。在《Java虚拟机规范》中对Java堆的描述是:“所有 的对象实例以及数组都应当在堆上分配[1]”,而这里笔者写的“几乎”是指从实现角度来看,随着Ja...

ywl470812087的博客 9万+
上一篇: 一起来学 SpringBoot 2.x | 第八篇:通用 Mapper 与分页插件的集成
下一篇: 闲话如何成为一个架构师
公众号-芋道源码
博客等级 码龄10年 1639粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值