性能测试总结之内存泄露和内存溢出
排查内存溢出的方法和步骤
排查内存溢出的方法和步骤内存溢出是软件开发中常见的问题，它会严重影响程序的性能和稳定性。
为了确保软件的优质运行，及时排查和解决内存溢出问题至关重要。
本文将详细介绍排查内存溢出的方法和步骤。
一、了解内存溢出在排查内存溢出之前，我们需要了解什么是内存溢出。
内存溢出是指程序在运行过程中，申请的内存超过了系统能够提供的最大内存限制，导致程序无法正常运行。
内存溢出主要有以下几种类型：1.堆内存溢出：指程序在堆内存中申请的空间超过了限制。
2.栈内存溢出：指程序在栈内存中申请的空间超过了限制。
3.全局内存溢出：指程序在全局内存中申请的空间超过了限制。
二、排查内存溢出的方法1.分析程序代码（1）检查内存申请和释放的逻辑是否正确。
（2）检查是否存在内存泄露的情况，如已释放的内存还被程序使用。
（3）检查程序中是否存在大量临时对象创建和销毁，导致内存频繁申请和释放。
2.使用内存分析工具（1）Visual Studio Memory Profiler：适用于Windows平台的内存分析工具，可以监测程序运行过程中的内存使用情况，定位内存溢出问题。
（2）Valgrind：适用于Linux平台的内存分析工具，可以检测内存泄露、内存越界等问题。
（3）Xcode Memory Graph：适用于iOS和macOS平台的内存分析工具，可以查看内存使用情况，分析内存泄露等问题。
3.动态监测内存使用在程序运行过程中，实时监测内存使用情况，观察内存是否持续上升。
可以通过以下方法进行动态监测：（1）编写内存监控代码，定期输出程序内存使用情况。
（2）使用操作系统提供的命令行工具，如Windows的任务管理器、Linux的top和ps命令等。
三、排查内存溢出的步骤1.确定内存溢出的类型和范围。
2.使用分析工具或动态监测方法，定位内存溢出的问题代码。
3.修复问题代码，如优化内存申请和释放逻辑、消除内存泄露等。
4.重新运行程序，验证内存溢出问题是否已解决。
内存泄露和内存溢出的原因
内存泄露和内存溢出的原因
内存泄漏是指计算机程序中分配的内存空间没有被释放，即无法
再次使用，而导致程序内存不足的问题。
这主要是由于程序设计问题，比如没有释放不需要的内存，以及循环引用等问题导致内存一直被占用。
内存溢出是指程序要求的内存超出了计算机系统可用内存的情况，这可能由于程序设计问题、数据结构问题，或者计算机系统本身的内
存限制造成。
例如，在递归函数中无限制的调用自身，导致栈空间直
接爆满，就属于典型的内存溢出情况。
对于内存泄漏和内存溢出问题，我们应该及时识别并解决。
对于
内存泄漏问题，可以使用垃圾回收算法等手段来自动回收不再使用的
内存，同时程序代码也应该优化，确保在不需要使用某些内存时及时
释放。
对于内存溢出问题，则需要优化算法、减少内存使用，或是升
级计算机硬件等措施来解决。
内存泄露和内存溢出的原因
内存泄露和内存溢出的原因
内存泄露和内存溢出是常见的程序运行问题，导致程序的性能下降或崩溃。
其原因可能来自以下几个方面：
1. 代码错误：程序员编写的代码中可能存在逻辑错误或者疏忽导致内存泄露或者溢出。
2. 无限循环：程序中的无限循环会不断占用内存，当内存达到极限时，程序就会崩溃或者出现内存溢出的问题。
3. 大量数据处理：当程序需要处理大量的数据时，如果没有合理地管理内存，就会导致内存溢出。
4. 内存管理不当：内存管理不当也会导致内存泄露或者溢出。
比如，如果程序没有及时释放不再使用的内存，就会导致内存泄露；如果程序请求的内存超过了系统所能提供的内存，就会导致内存溢出。
5. 外部因素：除了程序内部的原因，外部因素也可能导致内存泄露或者溢出。
比如，系统资源不足、硬件故障、病毒攻击等都会影响程序的内存使用情况。
综上所述，内存泄露和内存溢出的原因可能来自多个方面，程序员在编写程序时需要格外注意，合理管理内存，避免出现这些问题。
- 1 -。
内存溢出和内存泄漏的区别，产生原因以及解决方案
内存溢出和内存泄漏的区别，产⽣原因以及解决⽅案1.1内存溢出：（Out Of Memory---OOM）系统已经不能再分配出你所需要的空间，⽐如你需要100M的空间，系统只剩90M了，这就叫内存溢出例⼦：⼀个盘⼦⽤尽各种⽅法只能装4个果⼦，你装了5个，结果掉倒地上不能吃了。
这就是溢出。
⽐⽅说栈，栈满时再做进栈必定产⽣空间溢出，叫上溢，栈空时再做退栈也产⽣空间溢出，称为下溢。
就是分配的内存不⾜以放下数据项序列,称为内存溢出。
说⽩了就是我承受不了那么多，那我就报错，1.2内存泄漏： (Memory Leak)----》强引⽤所指向的对象不会被回收，可能导致内存泄漏，虚拟机宁愿抛出OOM也不会去回收他指向的对象意思就是你⽤资源的时候为他开辟了⼀段空间，当你⽤完时忘记释放资源了，这时内存还被占⽤着，⼀次没关系，但是内存泄漏次数多了就会导致内存溢出例⼦：你向系统申请分配内存进⾏使⽤(new)，可是使⽤完了以后却不归还(delete)，结果你申请到的那块内存你⾃⼰也不能再访问（也许你把它的地址给弄丢了），⽽系统也不能再次将它分配给需要的程序。
就相当于你租了个带钥匙的柜⼦，你存完东西之后把柜⼦锁上之后，把钥匙丢了或者没有将钥匙还回去，那么结果就是这个柜⼦将⽆法供给任何⼈使⽤，也⽆法被垃圾回收器回收，因为找不到他的任何信息。
⼀般我们所说的内存泄漏指的是堆内存的泄露，堆内存是指程序从堆中分配的，⼤⼩随机的⽤完后必须显⽰释放的内存，C++/C中有free函数可以释放内存，java中有垃圾回收机制不⽤程序员⾃⼰⼿动调⽤释放如果这块内存不释放，就不能再⽤了，这就叫这块内存泄漏了--------------------------------------------------------------------------------------------------------------------------------------------------------------------2.以发⽣的⽅式来分类，内存泄漏可以分为4类：1. 常发性内存泄漏。
内存泄漏和内存溢出、堆内存和栈内存区分、负载标准、降低cache内存方法
（一）内存泄漏和内存溢出内存溢出 out of memory，是指程序在申请内存时，没有足够的内存空间供其使用，出现out of memory；比如申请了一个integer,但给它存了long才能存下的数，那就是内存溢出。
内存溢出就是你要求分配的内存超出了系统能给你的，系统不能满足需求，于是产生溢出。
内存泄露 memory leak，是指程序在申请内存后，无法释放已申请的内存空间，一次内存泄露危害可以忽略，但内存泄露堆积后果很严重，无论多少内存,迟早会被占光。
内存泄漏是指你向系统申请分配内存进行使用(new)，可是使用完了以后却不归还(delete)，结果你申请到的那块内存你自己也不能再访问（也许你把它的地址给弄丢了），而系统也不能再次将它分配给需要的程序。
memory leak会最终会导致out of memory。
（二）堆内存和栈内存区分一、数据结构中的堆和栈1. 栈是一种连续储存的数据结构，具有先进后出的性质。
通常的操作有入栈（压栈），出栈和栈顶元素。
想要读取栈中的某个元素，就是将其之间的所有元素出栈才能完成。
2. 堆是一种非连续的树形储存数据结构，每个节点有一个值，整棵树是经过排序的。
特点是根结点的值最小（或最大），且根结点的两个子树也是一个堆。
常用来实现优先队列，存取随意。
二、内存中的栈区与堆区1. 内存中的栈区与堆区比较2. 计算机内存的大致划分一般说到内存，指的是计算机的随机存储器（RAM），程序都是在这里面运行。
三、栈内存与栈溢出由程序自动向操作系统申请分配以及回收，速度快，使用方便，但程序员无法控制。
若分配失败，则提示栈溢出错误。
注意，const 局部变量也储存在栈区内，栈区向地址减小的方向增长。
四、堆内存与内存泄露程序员向操作系统申请一块内存，当系统收到程序的申请时，会遍历一个记录空闲内存地址的链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序。
内存溢出的三种情况及系统配置解决方案
内存溢出的三种情况及系统配置解决方案内存溢出是指程序在运行过程中申请的内存超过了系统所分配的内存空间，导致程序崩溃或出现异常。
内存溢出通常是由于程序设计或系统配置问题引起的。
以下是三种常见的内存溢出情况及相应的系统配置解决方案。
1.单个进程占用内存过大：当一些进程在运行过程中占用的内存超过系统分配的限制时，就会导致内存溢出。
这种情况通常发生在大型应用程序或者后台服务运行时。
解决方案：-增加物理内存：在服务器或计算机中增加物理内存，以满足进程运行所需的内存空间。
-调整虚拟内存：将物理内存和虚拟内存结合使用，允许操作系统使用虚拟内存作为物理内存的扩展，从而提供更大的内存容量。
-优化应用程序：通过优化程序代码、降低内存使用、合理管理资源等方法，减少进程对内存的占用。
2.长时间运行的应用程序产生泄露：有些应用程序在长时间运行后会产生内存泄露的问题，即分配并使用内存后没有将其释放，导致内存占用逐渐增加，最终导致内存溢出。
解决方案：-使用垃圾回收机制：在一些支持垃圾回收的编程语言中，通过垃圾回收机制可以自动释放未使用的内存。
开发人员可以使用这些机制来解决内存泄露问题。
-引入内存监控工具：使用内存监控工具来检测应用程序中的内存泄露，定位并解决导致内存泄露的代码问题。
-定期重启应用程序：定期重启应用程序可以清理内存，防止内存泄露导致内存溢出。
3.大规模并发请求导致内存压力增加：在高并发的情况下，当系统同时处理大量的请求时，每个请求所占用的内存可能累积增加，导致整体内存压力增加，最终出现内存溢出。
解决方案：-加大系统负载均衡能力：通过增加负载均衡器、引入缓存机制等方式，将请求分散到多台服务器上，减少单台服务器的内存压力。
-优化数据库访问：对于一些频繁读写数据库的操作，可以通过合理的数据库设计、使用索引、缓存查询结果等方法，减少对数据库的访问，降低内存压力。
-调整服务器配置：合理设置服务器的最大并发连接数、线程池大小等参数，根据实际需求分配内存资源。
内存泄漏的检测定位和解决经验总结
内存泄漏的检测定位和解决经验总结内存泄漏是指程序在运行过程中，分配的内存没有被正确释放，导致内存资源无法被再次利用的情况。
由于没有及时释放内存，内存泄漏会导致系统的内存消耗不断增加，最终可能造成程序崩溃或者系统运行缓慢。
解决内存泄漏问题需要进行检测、定位和解决。
一、内存泄漏的检测1. 使用内存分析工具：可以使用一些专门的内存分析工具来检测内存泄漏问题，例如Valgrind、Memcheck等。
这些工具可以跟踪程序运行过程中的内存分配和释放，帮助定位内存泄漏的位置。
2.编写测试用例：通过编写一些针对性的测试用例，模拟程序运行过程中常见的内存分配和释放场景，观察内存的使用情况。
如果发现内存占用持续增长或者没有被及时释放，就可以判断存在内存泄漏问题。
3.监控系统资源：通过监控系统的资源使用情况，如内存占用、CPU使用率等，可以观察系统是否存在内存泄漏的迹象。
如果发现系统的内存占用不断增加，并且没有明显的释放情况，就需要进一步检查是否存在内存泄漏。
二、内存泄漏的定位1.使用日志输出：通过在程序中添加日志输出语句，记录程序运行过程中的重要信息，特别是涉及内存分配和释放的地方。
通过观察日志输出，可以发现是否有内存没有被正确释放的情况。
2.代码分析：通过代码分析，找出可能导致内存泄漏的地方。
常见的内存泄漏问题包括：不恰当的内存分配和释放顺序、不正确的内存释放方式、内存分配大小不匹配等。
对于涉及动态分配内存的地方，要特别关注是否有被遗漏的释放操作。
3.堆栈跟踪：当发现内存泄漏问题比较复杂或者难以定位时，可以使用堆栈跟踪来追踪内存分配和释放的调用路径，找出内存泄漏的具体位置。
在调试过程中，可以通过打印调用栈来获取函数调用的过程，进而确定哪个函数没有正确释放内存。
三、内存泄漏的解决1.及时释放内存：在程序中，所有动态分配的内存都需要及时释放。
对于每个内存分配操作，都要确保相应的释放操作存在，并且在适当的时候进行调用。
内存溢出和内存泄漏的区别
内存溢出和内存泄漏的区别（内存泄漏原因）内存溢出out of memory，是指程序在申请内存时，没有足够的内存空间供其使用，出现out of memory；比如申请了一个integer,但给它存了long才能存下的数，那就是内存溢出。
内存泄露memory leak，是指程序在申请内存后，无法释放已申请的内存空间，一次内存泄露危害可以忽略，但内存泄露堆积后果很严重，无论多少内存,迟早会被占光。
memory leak会最终会导致out of memory！内存溢出就是你要求分配的内存超出了系统能给你的，系统不能满足需求，于是产生溢出。
内存泄漏是指你向系统申请分配内存进行使用(new)，可是使用完了以后却不归还(delete)，结果你申请到的那块内存你自己也不能再访问（也许你把它的地址给弄丢了），而系统也不能再次将它分配给需要的程序。
一个盘子用尽各种方法只能装4个果子，你装了5个，结果掉倒地上不能吃了。
这就是溢出！比方说栈，栈满时再做进栈必定产生空间溢出，叫上溢，栈空时再做退栈也产生空间溢出，称为下溢。
就是分配的内存不足以放下数据项序列,称为内存溢出.以发生的方式来分类，内存泄漏可以分为4类：1. 常发性内存泄漏。
发生内存泄漏的代码会被多次执行到，每次被执行的时候都会导致一块内存泄漏。
2. 偶发性内存泄漏。
发生内存泄漏的代码只有在某些特定环境或操作过程下才会发生。
常发性和偶发性是相对的。
对于特定的环境，偶发性的也许就变成了常发性的。
所以测试环境和测试方法对检测内存泄漏至关重要。
3. 一次性内存泄漏。
发生内存泄漏的代码只会被执行一次，或者由于算法上的缺陷，导致总会有一块仅且一块内存发生泄漏。
比如，在类的构造函数中分配内存，在析构函数中却没有释放该内存，所以内存泄漏只会发生一次。
4. 隐式内存泄漏。
程序在运行过程中不停的分配内存，但是直到结束的时候才释放内存。
严格的说这里并没有发生内存泄漏，因为最终程序释放了所有申请的内存。
内存泄漏的检测定位和解决经验总结
内存泄漏的检测定位和解决经验总结内存泄漏是指在程序运行过程中，分配的内存一直没有被释放，导致内存的使用量越来越大，最终耗尽系统资源，造成程序崩溃。
内存泄漏是一种常见的程序缺陷，需要及时发现和解决。
一、检测内存泄漏的方法有以下几种：1. 静态代码检查：通过静态代码分析工具进行检查，工具可以扫描代码中的内存分配和释放情况，并发现潜在的内存泄漏问题。
常用的静态代码检查工具包括Coverity、PMD等。
2. 动态代码检查：通过运行时检查工具对程序进行监控，记录内存分配和释放的情况，检查是否有未释放的内存。
常用的动态代码检查工具包括Valgrind、Dr.Memory等。
3. 内存使用分析工具：通过监控程序的内存使用情况，包括内存的分配与释放，内存占用量等信息，来判断是否存在内存泄漏。
常用的内存使用分析工具有Google Performance Tools、Eclipse Memory Analyzer 等。
二、定位内存泄漏的方法有以下几种：1.添加日志：在程序中添加日志跟踪内存的分配与释放情况，当发现内存没有被释放时，通过日志定位问题的位置。
可以通过添加打印语句或者使用专门的日志工具来完成日志记录。
2. 使用内存调试工具：内存调试工具可以跟踪程序中的内存分配和释放情况，并将未被释放的内存标记出来。
通过分析工具提供的报告，可以定位内存泄漏的位置。
常用的内存调试工具有Valgrind、Dr.Memory等。
3. 内存堆栈分析：当程序出现内存泄漏时，通过分析内存堆栈可以得到导致内存泄漏的代码路径。
可以使用工具来进行内存堆栈分析，例如Eclipse Memory Analyzer。
三、解决内存泄漏的方法有以下几种：1. 显式释放内存：在程序中显式地调用释放内存的函数，确保内存被正确地释放。
例如，在使用动态内存分配函数malloc或new分配内存后，必须使用free或delete释放内存。
2. 自动垃圾回收：使用编程语言或框架提供的垃圾回收机制，自动释放不再使用的内存。
Python内存泄漏和内存溢出的解决方案
Python内存泄漏和内存溢出的解决⽅案⼀、内存泄漏像Java程序⼀样，虽然Python本⾝也有垃圾回收的功能，但是同样也会产⽣内存泄漏的问题。
对于⼀个⽤ python 实现的，长期运⾏的后台服务进程来说，如果内存持续增长，那么很可能是有了“内存泄露”。
1、内存泄露的原因对于 python 这种⽀持垃圾回收的语⾔来说，怎么还会有内存泄露？概括来说，有以下三种原因：所⽤到的⽤ C 语⾔开发的底层模块中出现了内存泄露。
代码中⽤到了全局的 list、 dict 或其它容器，不停的往这些容器中插⼊对象，⽽忘记了在使⽤完之后进⾏删除回收代码中有“引⽤循环”，并且被循环引⽤的对象定义了__del__⽅法，就会发⽣内存泄露。
为什么循环引⽤的对象定义了__del__⽅法后collect就不起作⽤了呢？gc模块最常使⽤的⽅法就是gc.collect()⽅法，使⽤collect⽅法对循环引⽤的对象进⾏垃圾回收。
如果我们在类中重载了__del__⽅法。
__del__⽅法定义了在⽤del语句删除对象时除了释放内存空间以外的操作。
⼀般⽽⾔，在使⽤了del语句的时候解释器⾸先会看要删除对象的引⽤计数，如果为0，那么就释放内存并执⾏del⽅法。
在这⾥，⾸先del语句出现时本⾝引⽤计数就不为0（因为有循环引⽤的存在），所以解释器不释放内存；再者，执⾏collect⽅法时应该会清除循环引⽤所产⽣的⽆效引⽤计数从⽽达到del的⽬的，对于这两个循环引⽤对象⽽⾔，python⽆法判断调⽤它们的del⽅法时会不会要⽤到对⽅那个对象，⽐如在进⾏b.del()时可能会⽤到b._a也就是a，如果在那之前a已经被释放，那么就彻底GG了。
为了避免这种情况，collect⽅法默认不对重载了del⽅法的循环引⽤对象进⾏回收，⽽它们俩的状态也会从unreachable转变为uncollectable。
由于是uncollectable的，⾃然就不会被collect处理，所以就进⼊了garbage列表。
检测内存溢出的方法
检测内存溢出的方法
内存溢出是一种常见的程序错误，它通常发生在程序运行过程中，当程序试图分配超过其可用内存容量的对象时。
这种错误会导致程序崩溃或异常终止，严重影响程序的功能和稳定性。
为了避免这种错误的发生，我们需要及时检测和解决内存溢出问题。
以下是一些常用的检测内存溢出的方法：
1. 监控内存使用情况
通过监控程序的内存使用情况，及时发现内存泄漏或使用过度的情况。
可以使用系统工具或第三方工具来监控内存使用情况，例如Linux下的top、htop命令或者Java VisualVM等工具。
2. 执行代码分析
通过执行代码分析工具，可以检测出代码中存在的内存泄漏等问题。
常用的代码分析工具有Valgrind、Eclipse Memory Analyzer等。
3. 进行压力测试
通过模拟实际运行环境下的高负载情况，检测程序在压力下是否会发生内存溢出等错误。
可以使用JMeter等工具进行压力测试。
4. 使用断言
在程序中加入断言语句，判断内存分配是否成功，避免程序在分配内存失败时继续运行而导致崩溃。
总之，内存溢出是一个非常棘手的问题，需要我们及时发现和修复。
以上提到的方法只是其中一部分，更多的解决方法需要我们在实际开发中积累和总结。
性能测试常见问题总结（上）
性能测试常见问题总结（上）⼀、内存溢出的问题1、堆内存溢出 （1）压测执⾏⼀段时间后，系统处理能⼒下降。
这时⽤JConsole、JVisualVM等⼯具连上服务器查看GC情况，每次GC回收都不彻底并且可⽤堆内存越来越少（证明已经出现了内存泄漏的现象，继续2）。
（2）压测持续下去，最终在⽇志中有报错信息：ng.OutOfMemoryError.Java heap space。
定位⽅法： （1）使⽤jmap -histo 进程id > test.txt 命令将堆内存使⽤情况保存到test.txt⽂件中，打开⽂件查看排在前20的类名中有没有⾃⼰公司项⽬的类名，如果有则基本可以定位堆内存溢出是这个类导致的。
（2）如果没有，则使⽤命令：jmap -dump:live,format=b,file=test.dump 进程id⽣成test.dump⽂件，然后使⽤MAT⼯具进⾏堆内存分析。
2、持久代溢出（1）压测执⾏⼀段时间后，⽇志中报错：ng.OutOfMemoryError: PermGen space（这个报错是持久代溢出的标识）。
产⽣原因：由于类、⽅法描述、字段描述、常量池、访问修饰符等⼀些静态变量太多，将持久代空间占满导致溢出。
解决⽅法：修改JVM参数，将XX:MaxPermSize参数调⼤既可以解决，建议代码中尽量减少静态变量。
3、栈内存溢出（1）压测执⾏⼀段时间后，⽇志中报错：ng.StackOverflowError（这个报错是栈内存溢出的标识）产⽣原因：⼀般是递归没返回，批量操作数据，循环调⽤等造成。
解决⽅法：修改JVM参数，将Xss参数改⼤，增加栈内存4、系统内存溢出（1）压测执⾏⼀段时间后，⽇志中出现报错：ng.OutOfMemoryError: unable to create new native thread。
产⽣原因：操作系统没有⾜够的系统资源造成的，系统创建线程时，除了要在Java堆中分配内存外，操作系统本⾝也需要分配资源来创建线程。
内存六种异常故障及解决方法
内存六种异常故障及解决方法内存是计算机的核心组件之一，它负责存储和处理数据。
然而，由于各种原因，内存可能会出现异常故障。
本文将介绍六种常见的内存异常故障，并提供相应的解决方法。
1.内存溢出：当程序执行时，它需要在内存中分配一定的空间来存储数据和指令。
如果程序需要的空间超过了可用的内存大小，就会发生内存溢出。
这通常是由于程序运行时使用了过多的内存资源。
解决方法：增加内存容量或者优化程序代码，减少内存的使用量。
2.内存泄漏：内存泄漏是指程序分配了内存空间，但在不再需要这些空间时没有释放。
每次发生内存泄漏，系统可用内存都会减少，并且程序的性能会受到影响。
解决方法：定期进行内存泄漏检测，及时释放不再使用的内存空间。
3.内存错误：内存错误可能包括写入了错误的数据、读取了未初始化的内存、越界访问等。
这些错误可能会导致程序崩溃或提供错误的结果。
解决方法：通过对程序进行测试和调试，找出并修复内存错误。
4.外部冲突：外部冲突是指其他硬件或软件组件对内存资源的干扰。
这可能包括其他程序的内存错误、硬件故障或操作系统故障等。
解决方法：检查其他程序和硬件设备，确保它们没有对内存资源进行干扰。
如果检测到故障，及时修复或更换相应的组件。
5.内存速度问题：内存速度问题是指内存读取和写入数据的速度较慢。
这可能是由于内存模块老化、不匹配的内存模块或者不兼容的操作系统引起的。
解决方法：检查内存模块并确保其工作正常。
如果存在问题，可以更换内存模块或调整操作系统设置。
6.电源问题：电源问题可能导致内存故障，例如电压不稳定、电源线松动等。
这些问题可能会导致内存读写错误和数据损坏。
解决方法：检查电源连接是否牢固，确保电压稳定。
如果问题仍然存在，可能需要更换电源供应器。
总结起来，内存六种异常故障及解决方法如下：1.内存溢出：增加内存容量或者优化程序代码，减少内存的使用量。
2.内存泄漏：定期进行内存泄漏检测，及时释放不再使用的内存空间。
3.内存错误：通过对程序进行测试和调试，找出并修复内存错误。
内存抖动，内存泄漏，内存溢出，内存碎片
内存抖动，内存泄漏，内存溢出，内存碎⽚内存抖动内存抖动：指在短时间内有⼤量的对象被创建或者被回收的现象。
内存抖动产⽣原因：主要是频繁(很重要)在循环⾥创建对象(导致⼤量对象在短时间内被创建，由于新对象是要占⽤内存空间的⽽且是频繁，如果⼀次或者两次在循环⾥创建对象对内存影响不⼤，不会造成严重内存抖动这样可以接受也不可避免，频繁的话就很内存抖动很严重)，内存抖动的影响是如果抖动很频繁，会导致垃圾回收机制频繁运⾏(短时间内产⽣⼤量对象，需要⼤量内存，⽽且还是频繁抖动，就可能会需要回收内存以⽤于产⽣对象，垃圾回收机制就⾃然会频繁运⾏了)。
内存抖动影响：频繁内存抖动会导致垃圾回收频繁运⾏，造成系统卡顿。
内存泄露内存泄漏（ Memory Leak ）是指程序中⼰动态分配的堆内存由于某种原因程序未释放或⽆法释放，造成系统内存的浪费，导致程序运⾏速度减慢甚⾄系统崩溃等严重后果。
内存溢出内存溢出(Out Of Memory，简称OOM)是指应⽤系统中存在⽆法回收的或使⽤的过多，最终使得程序运⾏要⽤到的⼤于能提供的最⼤内存。
此时就运⾏不了，系统会提⽰内存溢出，有时候会软件，重启电脑或者软件后释放掉⼀部分内存⼜可以正常运⾏该软件，⽽由、、⽤户代码等原因⽽导致的内存溢出错误，即使⽤户重新执⾏任务依然⽆法避免内存溢出和内存泄漏系统已经不能再分配出你所需要的空间，⽐如你需要100M的空间，系统只剩90M了，这就叫内存溢出强引⽤所指向的对象不会被回收，可能导致内存泄漏，虚拟机宁愿抛出OOM也不会去回收他指向的对象意思就是你⽤资源的时候为他开辟了⼀段空间，当你⽤完时忘记释放资源了，这时内存还被占⽤着，⼀次没关系，但是内存泄漏次数多了就会导致内存溢出内存碎⽚内存碎⽚通常分为内部碎⽚和外部碎⽚：内部碎⽚是由于采⽤固定⼤⼩的内存分区，当⼀个进程不能完全使⽤分给它的固定内存区域时就产⽣了内部碎⽚，通常内部碎⽚难以完全避免。
外部碎⽚是由于某些未分配的连续内存区域太⼩，以⾄于不能满⾜任意进程的内存分配请求，从⽽不能被进程利⽤的内存区域。
内存溢出的几种原因和解决办法
内存溢出的⼏种原因和解决办法对于JVM的内存写过的⽂章已经有点多了，⽽且有点烂了，不过说那么多⼤多数在解决OOM的情况，于此，本⽂就只阐述这个内容，携带⼀些分析和理解和部分扩展内容，也就是JVM宕机中的⼀些问题，OK，下⾯说下OOM的常见情况：第⼀类内存溢出，也是⼤家认为最多，第⼀反应认为是的内存溢出，就是堆栈溢出：那什么样的情况就是堆栈溢出呢？当你看到下⾯的关键字的时候它就是堆栈溢出了：ng.OutOfMemoryError: ......java heap space.....也就是当你看到heap相关的时候就肯定是堆栈溢出了，此时如果代码没有问题的情况下，适当调整-Xmx和-Xms是可以避免的，不过⼀定是代码没有问题的前提，为什么会溢出呢，要么代码有问题，要么访问量太多并且每个访问的时间太长或者数据太多，导致数据释放不掉，因为垃圾回收器是要找到那些是垃圾才能回收，这⾥它不会认为这些东西是垃圾，⾃然不会去回收了；主意这个溢出之前，可能系统会提前先报错关键字为：ng.OutOfMemoryError:GC over head limit exceeded这种情况是当系统处于⾼频的GC状态，⽽且回收的效果依然不佳的情况，就会开始报这个错误，这种情况⼀般是产⽣了很多不可以被释放的对象，有可能是引⽤使⽤不当导致，或申请⼤对象导致，但是java heap space的内存溢出有可能提前不会报这个错误，也就是可能内存就直接不够导致，⽽不是⾼频GC.第⼆类内存溢出，PermGen的溢出，或者PermGen 满了的提⽰，你会看到这样的关键字：关键信息为:ng.OutOfMemoryError: PermGen space原因：系统的代码⾮常多或引⽤的第三⽅包⾮常多、或代码中使⽤了⼤量的常量、或通过intern注⼊常量、或者通过动态代码加载等⽅法，导致常量池的膨胀，虽然JDK 1.5以后可以通过设置对永久带进⾏回收，但是我们希望的是这个地⽅是不做GC的，它够⽤就⾏，所以⼀般情况下今年少做类似的操作，所以在⾯对这种情况常⽤的⼿段是：增加-XX:PermSize和-XX:MaxPermSize的⼤⼩。
内存溢出和内存泄漏是什么
内存溢出和内存泄漏是什么在现如今这个电子信息时代，几乎每个人都离不开网络、离不开电子产品，而内存在电子产品里有至关重要的作用，这里给大家分享一些关于内存溢出和内存泄漏是什么，希望对大家能有所帮助。
内存溢出是什么意思内存溢出就是你要求分配的内存超出了系统能给你的，系统不能满足需求，于是产生溢出。
为了便于理解我们可以有个形象的比喻就是“操作系统可提供给所有进程的存储空间正在被某个进程榨干”，最终结果是程序运行时间越长，占用存储空间越来越多，最终用尽全部存储空间，整个系统崩溃。
所以“内存泄漏”是从操作系统的角度来看的。
这里的存储空间并不是指物理内存，而是指虚拟内存大小，这个虚拟内存大小取决于磁盘交换区设定的大小。
由程序申请的一块内存，如果没有任何一个指针指向它，那么这块内存就泄漏了。
内存泄漏是什么内存泄露指由于疏忽或错误造成程序未能释放已经不再使用的内存的情况。
内存泄漏并非指内存在物理上的消失，而是应用程序分配某段内存后，由于设计错误，失去了对该段内存的控制，因而造成了内存的浪费。
为了便于理解，我们不妨打个比方。
缓冲区溢出好比是将十磅的糖放进一个只能装五磅的容器里。
一旦该容器放满了，余下的部分就溢出在柜台和地板上，弄得一团糟。
由于计算机程序的编写者写了一些编码，但是这些编码没有对目的区域或缓冲区——五磅的容器——做适当的检查，看它们是否够大，能否完全装入新的内容——十磅的糖，结果可能造成缓冲区溢出的产生。
如果打算被放进新地方的数据不适合，溢得到处都是，该数据也会制造很多麻烦。
但是，如果缓冲区仅仅溢出，这只是一个问题。
到此时为止，它还没有破坏性。
当糖溢出时，柜台被盖住。
可以把糖擦掉或用吸尘器吸走，还柜台本来面貌。
与之相对的是，当缓冲区溢出时，过剩的信息覆盖的是计算机内存中以前的内容。
除非这些被覆盖的内容被保存或能够恢复，否则就会永远丢失。
发生内存泄漏的程序很多，但是要想产生一定的后果，就需要这个进程是无限循环的，是个服务进程。
JVM内存溢出详解（栈溢出，堆溢出，持久代溢出、无法创建本地线程）
JVM内存溢出详解（栈溢出，堆溢出，持久代溢出、⽆法创建本地线程）1、内存溢出和内存泄漏的区别 内存溢出（Out Of Memory）：是指程序在申请内存时，没有⾜够的内存空间供其使⽤，出现Out Of Memory。
内存泄露（Memory Leak）：是指程序在申请内存后，由于某种原因⽆法释放已申请的内存空间，导致这块内存⽆法再次被利⽤，造成系统内存的浪费。
memory leak会最终会导致out of memory。
2、内存溢出分类2.1 栈内存溢出（StackOverflowError）： 程序所要求的栈深度过⼤导致，可以写⼀个死递归程序触发。
2.2 堆内存溢出(OutOfMemoryError : java heap space)需要分清是内存溢出还是内存泄漏：（1）如果是内存溢出，则通过调⼤ -Xms，-Xmx参数。
（2）如果是内存泄露，则看对象如何被 GC Root 引⽤。
2.3 持久带内存溢出(OutOfMemoryError: PermGen space)持久带中包含⽅法区，⽅法区包含常量池。
因此持久带溢出有可能是（1）运⾏时常量池溢出，也有可能是（2）⽅法区中保存的Class对象没有被及时回收掉或者Class信息占⽤的内存超过了我们配置。
⽤String.intern()触发常量池溢出。
Class对象未被释放，Class对象占⽤信息过多，有过多的Class对象。
可以导致持久带内存溢出。
2.4 ⽆法创建本地线程Caused by: ng.OutOfMemoryError:unable to create new native thread系统内存的总容量不变，堆内存、⾮堆内存设置过⼤，会导致能给线程分配的内存不⾜。
3、内存溢出详解3.1 栈溢出（StackOverflowError） 栈溢出抛出 StackOverflowError 错误，出现此种情况是因为⽅法运⾏的时候栈的深度超过了虚拟机容许的最⼤深度所致。
内存溢出出现原因及解决方案
内存溢出出现原因及解决方案篇一：内存溢出解决方案内存溢出解决方案篇二：内存溢出的三种情况及系统配置解决方案近经常有人咨询相关内存溢出的问题，在生产环境中tomcat内存设置不好很容易出现内存溢出。
造成内存原因是不一样的，当然处理方式也不一样。
这里根据平时遇到的情况和相关资料进行一个总结。
常见的一般会有下面三种情况：： Java heap space： PermGen space： unable to create new native thread.Tomcat内存溢出解决方案对于前两种情况，在应用本身没有内存泄露的情况下可以用设置tomcat jvm参数来解决。
（-Xms -Xmx -XX：PermSize -XX：MaxPermSize）最后一种可能需要调整操作系统和tomcat jvm参数同时调整才能达到目的。
第一种：是堆溢出。
在JVM中如果98％的时间是用于GC且可用的 Heap size不足2％的时候将抛出此异常信息。
没有内存泄露的情况下，调整-Xms -Xmx参数可以解决。
-Xms：初始堆大小-Xmx：最大堆大小但堆的大小受下面三方面影响：1.相关操作系统的数据模型（32-bt还是64-bit）限制；（32位系统下，一般限制在~2G；我在20XX server 系统下（物理内存：4G和6G，jdk：）测试 1612M，64为操作系统对内存无限制。
）2.系统的可用虚拟内存限制；3.系统的可用物理内存限制。
堆的大小可以使用 java -Xmx***M version 命令来测试。
支持的话会出现jdk的版本号，不支持会报错。
-Xms-Xmx一般配置成一样比较好比如set JAVA_OPTS= -Xms1024m -Xmx1024m第二种：永久保存区域溢出PermGen space的全称是Permanent Generation space，是指内存的永久保存区域。
这一部分用于存放Class和的信息，Class在被 Load的时候被放入PermGen space区域，它和和存放Instance的Heap区域不同，GC（Garbage Collection）不会在主程序运行期对PermGen space进行清理，所以如果你的APP会LOAD很多CLASS的话，就很可能出现PermGen space错误。
mat分析内存总结--性能分析
mat分析内存总结--性能分析主要是⼯作中发现后台项⽬有时候话boom，看⽇志也会偶尔看到内存不⾜的报错。
为了定位原因改善由于内存问题引起的性能问题特做个总结给⼤家参考。
主要分了三个阶段做这个事情。
由于截图及脚本涉及业务省略，有需要欢迎留⾔交流。
初步思路后台系统性能参考指标很多⽅⾯需要参考，本次实践主要针对应⽤服务器的内存作为主要检测指标。
主要思路如下：1、TOP+Hp找到最⼤耗cpu线程，依赖jstack简单的找到线程耗cpu所在堆栈2、实时监控内存回收状况如：jstat3、在内存回收异常点保存堆栈镜像如：hump -dump:live,format=b,file=heap.bin pid4、利⽤堆栈分析⼯具分析堆栈镜像定位可能耗性能代码第⼀阶段选⽤mat插件分析堆栈镜像，本地搭建好环境，主要⽬的及内容如下：1、搭建基于eclipse的mat插件2、确⽴主要检测指标及定位前提3、思考怎么实时监控性能的指标第⼆阶段在性能不好的情况分析堆栈最有可能发现性能瓶颈，镜像⽂件是保留现场的重要⽂件。
本阶段主要⼯作如下：1、根据不同项⽬进程id⾃动⽣成镜像⽂件2、常见场景如新⽼代内存使⽤率100%时，⾃动⽣成镜像⽂件3、学习并尝试引进⼀种⼯具或者脚本实时监控系统主要性能参数如：cpu、内存、磁盘IO、带宽等。
第三阶段mat⼯具及性能调优组内分享，并在使⽤中优化完善脚本。
主要内容：1、输出调优分享及mat搭建⽂档2、对使⽤过程提出的建议进⾏优化脚本3、对引进监控性能主要参数最后确定⼯具选择本阶段主要是选择分析堆栈的⼯具，及初步尝试使⽤⼯具定位堆栈镜像中使⽤内存的情况；梳理出常⽤定位步骤；编写或利⽤⼯具辅助监控内存的使⽤。
在⼯具选择mat插件（全称Memory Analyzer），和市场上其他同类⼯具如jvisualvm（jdk1.7以上⾃带）、jprofile等相⽐完胜对⼿。
⾸先他是⼀个插件相对jprofile⽽⾔更轻量，在分析打内存的堆栈来说效率更快；和jvisualvm相⽐提供了诸如Leak Suspects的报告，更直接准确的将可能有问题的地⽅暴露出来分析更准确。
内存泄漏测试与排查方法
内存泄漏测试与排查方法内存泄漏是软件开发过程中常见的问题之一，它会导致程序运行变慢、占用过多的系统资源，最终可能引发系统崩溃或应用程序崩溃。
因此，进行内存泄漏测试和排查方法是很重要的。
内存泄漏测试是为了发现应用程序中存在的内存泄漏问题。
下面将介绍一些常用的内存泄漏测试方法。
第一种方法是静态分析。
静态分析是通过检查源代码中可能导致内存泄漏的部分来判断内存泄漏问题。
可以使用静态代码分析工具来辅助进行该项测试。
这些工具可以帮助开发人员发现潜在的内存泄漏问题，如资源未释放、循环引用等。
在测试中，我们可以使用这些工具扫描应用程序的源代码，找出可能存在内存泄漏的地方，并及时修复。
第二种方法是动态分析。
动态分析是通过运行应用程序并监控其内存使用情况来检测内存泄漏。
在这种方法中，我们使用各种性能分析工具来监视应用程序的内存使用情况，例如内存分配和释放的次数、内存泄漏的对象等。
通过分析这些数据，我们可以确定是否存在内存泄漏问题，并找到导致内存泄漏的具体原因。
动态分析是一种非常常用和有效的方法，可以在应用程序运行时发现内存泄漏问题，并及时采取措施进行修复。
第三种方法是使用内存检测工具。
内存检测工具可以帮助开发人员检测内存泄漏问题，并提供详细的报告来指导修复。
这些工具可以监视应用程序运行时的内存分配和释放情况，并检查是否有未释放的内存块。
一旦发现内存泄漏问题，工具会生成相应的报告，指导开发人员进行修复。
常用的内存检测工具包括Valgrind、Memcheck等。
在排查内存泄漏问题时，我们需要注意以下几点。
定位内存泄漏问题。
通过使用上述方法检测和分析应用程序的内存使用情况，确定是否存在内存泄漏问题。
可以通过追踪对象的创建和销毁、监控内存的分配和释放等方法来定位问题。
分析内存泄漏原因。
一旦确定了存在内存泄漏问题，我们需要深入分析其原因。
可能的原因包括资源未正确释放、循环引用等。
修复内存泄漏问题。
根据分析结果，采取相应的措施进行修复。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
性能测试总结之内存泄露和内存溢出2009-12-10 作者：yunshuai来源：Taobao QA Team刚刚做完了一个项目的性能测试，“有幸”也遇到了内存泄露的案例，所以在此和大家分享一下。
主要从以下几部分来说明，关于内存和内存泄露、溢出的概念，区分内存泄露和内存溢出；内存的区域划分，了解GC回收机制；重点关注如何去监控内存问题；此外分析出问题还要如何解决内存问题。
下面就开始本篇的内容：第一部分概念众所周知，java中的内存java虚拟机自己去管理的，他不想C++需要自己去释放。
笼统地去讲，java的内存分配分为两个部分，一个是数据堆，一个是序在运行的时候一般分配数据堆，把局部的临时的变量都放进去，生命周期和进程有关系。
但是如果程序员声明了static的变量，就直接在栈中运行的，进了，不一定会销毁static变量。
另外为了保证java内存不会溢出，java中有垃圾回收机制。
System.gc()即垃圾收集机制是指jvm用于释放那些不再使用的对象所占用的内存。
java语言求jvm有gc，也没有规定gc如何工作。
垃圾收集的目的在于清除不再使用的对象。
gc通过确定对象是否被活动对象引用来确定是否收集该对象。
而其中，内存溢出就是你要求分配的java虚拟机内存超出了系统能给你的，系统不能满足需求，于是产生溢出。
内存泄漏是指你向系统申请分配内存进行使用(new)，可是使用完了以后却不归还(delete)，结果你申请到的那块内存你自己也不能再访问,该块已分配出存也无法再使用，随着服务器内存的不断消耗，而无法使用的内存越来越多，系统也不能再次将它分配给需要的程序，产生泄露。
一直下去，程序也逐渐使用，就会溢出。
第二部分原理JAVA垃圾回收及对内存区划分在Java虚拟机规范中，提及了如下几种类型的内存空间：◇栈内存（Stack）：每个线程私有的。
◇堆内存（Heap）：所有线程公用的。
◇方法区（Method Area）：有点像以前常说的“进程代码段”，这里面存放了每个加载类的反射信息、类函数的代码、编译时常量等信息。
◇原生方法栈（Native Method Stack）：主要用于JNI中的原生代码，平时很少涉及。
而Java的使用的是堆内存，java堆是一个运行时数据区，类的实例(对象)从中分配空间。
Java虚拟机(JVM)的堆中储存着正在运行的应用程序所建立的象，“垃圾回收”也是主要是和堆内存（Heap）有关。
垃圾回收的概念就是JAVA虚拟机（JVM）回收那些不再被引用的对象内存的过程。
一般我们认为正在被引用的对象状态为“alive”,而没有被应用或者取用属性的对象状态为“dead”。
垃圾回收是一个释放处于”dead”状态的对象的内存的过程。
而垃圾回收的规则和算法被动态的作用于应用运行当中，自动回JVM的垃圾回收器采用的是一种分代（generational ）回收策略，用较高的频率对年轻的对象(young generation)进行扫描和回收，这种叫做minor collec对老对象(old generation)的检查回收频率要低很多，称为major collection。
这样就不需要每次GC都将内存中所有对象都检查一遍，这种策略有利于实时观收。
（Sun JVM 1.3 有两种最基本的内存收集方式：一种称为copying或scavenge，将所有仍然生存的对象搬到另外一块内存后，整块内存就可回收。
这种效率，但需要有一定的空闲内存，拷贝也有开销。
这种方法用于minor collection。
另外一种称为mark-compact，将活着的对象标记出来，然后搬迁到一起块的内存，其他内存就可以回收了。
这种方法不需要占用额外的空间，但速度相对慢一些。
这种方法用于major collection. ）一些对象被创建出来只是拥有短暂的生命周期，比如iterators 和本地变量。
另外一些对象被创建是拥有很长的生命周期，比如高持久化对象等。
垃圾回收器的分代策略是把内存区划分为几个代，然后为每个代分配一到多个内存区块。
当其中一个代用完了分配给他的内存后，JVM会在分配的内存行一个局部的GC（也可以叫minor collection）操作，为了回收处于“dead”状态的对象所占用的内存。
局部GC通常要不Full GC要快很多。
JVM定义了两个代，年轻代（yong generation）（有时称为“nursery”托儿所）和老年代(old generation)。
年轻代包括“Eden space（伊甸园）”和两个“survivor 虚拟内存初始化的时候会把所有对象都分配到Eden space，并且大部分对象也会在该区域被释放。
当进行minor GC的时候，VM会把剩下的没有释放的Eden space移动到其中一个survivor spaces当中。
此外，VM也会把那些长期存活在survivor spaces 里的对象移动到老生代的“tenured” space中。
当tenured g 被填满后，就会产生Full GC，Full GC会相对比较慢因为回收的内容包括了所有的live状态的对象。
pemanet generation这个代包括了所有java虚拟机自身相对比较稳定的数据对象，比如类和对象方法等。
关于代的划分，可以从下图中获得一个概况：如果垃圾回收器影响了系统的性能，或者成为系统的瓶颈，你可以通过自定义各个代的大小来优化它的性能。
使用JConsole，可以方便的查看到当前应置的垃圾回收器的各个参数。
想要获得更详细的参数，可以参考以下调优介绍：Tuning Garbage collection with the 5.0 HotS pot V M/docs/hotspot/gc/index.html最后，总结一下各区内存：Eden Space (heap)：内存最初从这个线程池分配给大部分对象。
Survivor Space (heap)：用于保存在eden space内存池中经过垃圾回收后没有被回收的对象。
Tenured Generation (heap)：用于保持已经在survivor space内存池中存在了一段时间的对象。
Permanent Generation (non-heap): 保存虚拟机自己的静态(refective)数据，例如类（class）和方法（method）对象。
Java虚拟机共享这些类数据。
这个区割为只读的和只写的，Code Cache (non-heap):HotSpot Java虚拟机包括一个用于编译和保存本地代码（native code）的内存，叫做“代码缓存区”（code cache）第三部分监控（工具发现问题）谈到内存监控工具，JConsole是必须要介绍的，它是一个用JAVA写的GUI程序，用来监控VM，并可监控远程的V M，易用且功能强大。
具体可监控内存、JAVA CPU使用率、线程执行情况、加载类概况等，Jconsole需要在JVM参数中配置端口才能使用。
由于是GUI程序，界面可视化，这里就不做详细介绍，具体帮助支持文档请参阅性能测试JConsole使用方法总结：/chanpin/km/test/DocLib/性能测试辅助工具－JConsole的使用方法.aspx或者参考SUN官网的技术文档：/j2se/1.5.0/docs/guide/management/jconsole.html/javase/6/docs/technotes/tools/share/jconsole.html在实际测试某一个项目时，内存出现泄露现象。
起初在性能测试的1个小时中，并不明显，而在稳定性测试的时候才发现，应用的HSF调用在经过几个行后，就出现性能明显下降的情况。
在服务日志中报大量HSF超时，但所调用系统没有任何超时日志，并且压力应用的load都很低。
经过查看日志后，认可能存在内存泄漏。
通过jconsole 以及jmap 工具进行分析发现，确实存在内存泄漏问题，其中PS Old Gen最终达到占用100%的占用。
如图所示：从上图可以看到，虽然每次Full GC，JVM内存会有部分回收，但回收并不彻底，不可回收的内存对象会越来越多，这样便会出现以上的一个趋势。
在无法回收的对象越来越多时，最终已使用内存达到系统分配的内存最大值，系统最后无内存可分配，最终down机。
第四部分分析经过开发和架构师对应用的分析，查看此时内存队列，看哪个对象占用数据最多，再利用jmap命令，对线程数据分析，如下所示：num #instances #bytes class name———————————————-1: 9248056 665860032 com.taobao.matrix.mc.domain.**2: 9248031 295936992 com.taobao.matrix.**3: 9248068 147969088 java.util.**4: 1542111 37010664 java.util.Date前三个instances不断增加，指代的是同一个代码逻辑，异步分发的问题，堵塞消息，回收多次都无法回收成功。
导致内存溢出。
此外，对应用的性能单独做了压测，他的性能只能支撑到一半左右，故发送消息的TPS，应用肯定无法处理过来，导致消息堆积，而JAVA垃圾回收期些都是有用的对象，导致内存堆积，直至系统崩溃。
调优方法由于具体调优方法涉及到应用的配置信息，故在此暂不列出，可以参考性能测试小组发布的《性能测试调优宝典》第四部分总结内存溢出主要是由于代码编写时对某些方法、类应用不合理，或者没有预估到临时对象会占用很大内存量，或者把过多的数据放入JVM缓存，或者性大导致消息堆积而占用内存，以至于在性能测试时，生成庞大数量的临时对象，GC时没有做出有效回收甚至根本就不能回收，造成内存空间不足，内存如果编码之前，对内存使用量进行预估，对放在内存中的数据进行评估，保证有用的信息尽快释放，无用的信息能够被GC回收，这样在一定程度上是免内存溢出问题的。