内存泄漏是什么?

什么是内存泄漏?

一般我们常说的内存泄漏是指堆内存的泄漏。堆内存是指程序从堆中分配的，大小任意的工内存块的大小可以在程序运行期决定），使用完后必须显示释放的内存。应用程序一般使用malloc，realloc，new等函数从堆中分配到一块内存，使用完后，程序必须负责相应的调用free或delete释放该内存块，否则，这块内存就不能被再次使用，我们就说这块内存泄漏了。

请解释一下“内存泄漏”，这个问题会有什么影响

申请了内存不释放就是内存泄露 比如. void GetMemory(int len) { int *p =new int[len]} p申请了内存，但是函数返回了，没有指针的首地址传出来，不能释放了

内存泄漏是什么意思？简单说说就行了。

简单说 内存中的某一块正在被其他程序使用 这时如果再有其他程序试图使用这块内存 就会发生内存泄露

内存泄漏是指_______

选D项，实际上是堆内存分配后，至最终都没有被回收，始终被占用

最典型的例子是使用new分配内存，在整个程序中一直没有使用delete销毁，这就造成了使用new分配的那部分堆内存始终被占用(没有被释放)

内存泄露有一点想不明白，到底什么样才算内存泄漏

工具-选项-高级-更新-Firefox的对号去掉就行了。事实上3.0以后的版本对内存的管理更好了，内存泄露已经很少见了，但对于内存的最小值要求貌似更高一些，我曾经在256内存的电脑上使用3.6没什么问题，当然，由于cpu不足引起的flash响应慢就不算了。再小的内存就没用过了，不知道什么样。

什么是内存溢出与内存泄露，几种常见导致内存泄露的

内存溢出 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.内存中加载的数据量过于庞大，如一次从数据库取出过多数据；

2. *** 类中有对对象的引用，使用完后未清空，使得JVM不能回收；

3.代码中存在死循环或循环产生过多重复的对象实体；

4.使用的第三方软件中的BUG；

5.启动参数内存值设定的过小

内存溢出的解决方案：

第一步，修改JVM启动参数，直接增加内存。(-Xms，-Xmx参数一定不要忘记加。)

第二步，检查错误日志，查看逗OutOfMemory地错误前是否有其它异常或错误。

第三步，对代码进行走查和分析，找出可能发生内存溢出的位置。

重点排查以下几点：

1.检查对数据库查询中，是否有一次获得全部数据的查询。一般来说，如果一次取十万条记录到内存，就可能引起内存溢出。这个问题比较隐蔽，在上线前，数据库中数据较少，不容易出问题，上线后，数据库中数据多了，一次查询就有可能引起内存溢出。因此对于数据库查询尽量采用分页的方式查......>>

java内存泄露，是什么意思

内存泄露是指你申请了内存空间但是没有控制释放，然后那一块内存就被荒废了，你自己不用了，别人也用了不了，结果内存就被你占满了

什么是内在泄露...内存泄露了会有什么后果..??

内存泄漏是主内存分配了部分内存后而没有释放,逐渐耗尽内存资源，导致系统崩溃。它的后果甚至是会影响到以后内存的正常运行或使用内存损坏~~~ 它主要是指程序中间动态分配了内存，但是在程序结束时没有释放这部分内存，从而造成那一部分内存不可用的情况，重起计算机可以解决，但是也有可能再次发生内存泄露，内存泄露和硬件没有关系，它是由软件引起的。而在一般情况下无法轻易被发现的其实它也是轻易不是出现的,它就好象你坐在一个升降机里所在是13楼而你还按下13楼的按扭一样,内存泄露只会在这样的情况下出现的,不过内存泄露或者内存泄漏说还是会比一个人站在13楼还按要去13楼的按扭这样的情况要多的多,因为有时内存泄漏会时常发生在用户使用某些较大且较复杂的程序中~~~~处理的办法也只有使用一些软件来测试内存有没有这样泄露的问题了~~~~~不过要是隐性式的内存泄漏就不太好办了~~~要根据当前发生一些问题或是一些 *** 作来判断是否发生内存泄漏的问题

c++中中内存泄露有什么危害？

从用户使用程序的角度来看，内存泄漏本身不会产生什么危害。作为一般的用户，根本感觉不到内存泄漏的存在。真正有危害的是内存泄漏的堆积，这会最终消耗尽系统所有的内存。从这个角度来说，一次性内存泄漏并没有什么危害，因为它不会堆积。而隐式内存泄漏危害性则非常大，因为较之于常发性和偶发性内存泄礌它更难被检测到。存在内存泄漏问题的程序除了会占用更多的内存外，还会使程序的性能急剧下降。对于服务器而言，如果出现这种情况，即使系统不崩溃，也会严重影响使用。

不过还有一点，如果你的程序内存泄露正好写到了系统使用的内存或者其他程序使用的内存地址，那么就会导致系统异常或者程序崩溃

什么是内存泄漏 如何避免

内存泄漏的定义： 对象不再被应用程序使用，但是垃圾回收器却不能移除它们，因为它们正在被引用。

如何阻止内存泄漏？

以下是一些阻止内存泄漏的快速动手技巧。

（1）注意 *** 类，例如HashMap，ArrayList，等等。因为它们是内存泄漏经常发生的地方。当它们被声明为静态时，它们的生命周期就同应用程序的生命周期一般长。

（2）注意事件监听器和回调，如果一个监听器已经注册，但是当这个类不再被使用时却未被注销，就会发生内存泄漏。

（3）“如果一个类管理它自己的内存，程序员应该对内存泄漏保持警惕。”[1] 很多时候当一个对象的成员变量指向其他对象时，不再使用时需要被置为null。

希望这个回答对你有帮助

内存泄漏是在编写代码的时候最不想要遇到的情况之一，一旦是遇到了之后就需要停止已经运行的程序或程序根本就没有运行起来，找到出错的地方，进行修改，因为内存泄露本身是一种给数据分配了一个空间，但在结尾没有回收的现象，一旦是程序运行到了最后，就会提醒你出错，这里说一下内存泄露产生的几种原因。

一、单利静态造成

单例静态的未回收是内存泄露产生几种原因最常见的一种，因为单例静态自身的使用周期与应用的周期一样长，在漫长的使用过程之中，单例还占据着对象引用开辟出来的空间，会造成最后程序结尾的内存泄露。 就好比是我借了你的钱，你钱的一部分到了我的手上，并承诺规定时间内归还，但你忘了这件事情，那么就不还了，等着资金链断了才最终想起来这件事情。

二、内部类持有外部类

如果是一个外部类生成的一个实例对象，一直被内部类数据在使用着，到了最后哪个外部类已经不再使用了，但是内部类还是一直在使用，并没有对这段内存进行释放，所以这个外部类不回被回收，这也是产生内存泄露的一个原因。

三、库和协议的连接

当我们在进行数据库的连接，或者网络连接的过程之中，都需要用到数据进行传输，这个数据的使用，一直随着连接的关闭而停止，但是一直到最后，这种连接都没有关闭，就会造成大量的对象没有办法回收，从而造成了内存的泄露，已经应用的崩溃卡死。

四、变量不合理的定义域

在变量使用过程之中，要对变量的定义域进行约束，如果是变量定义域在使用的过程之中本身的范围超过了所需要的范围，并且没有置空，则就会造成内存泄露的出现。

（Memory Leak，内存泄漏）

当一个对象已经不需要再使用本该被回收时，另外一个正在使用的对象持有它的引用从而导致它不能被回收，这导致本该被回收的对象不能被回收而停留在堆内存中，这就产生了内存泄漏。

内存泄漏是造成应用程序OOM的主要原因之一。我们知道Android系统为每个应用程序分配的内存是有限的，而当一个应用中产生的内存泄漏比较多时，这就难免会导致应用所需要的内存超过系统分配的内存限额，这就造成了内存溢出从而导致应用Crash。

因为内存泄漏是在堆内存中，所以对我们来说并不是可见的。通常我们可以借助MAT、LeakCanary等工具来检测应用程序是否存在内存泄漏。

1、MAT是一款强大的内存分析工具，功能繁多而复杂。

2、LeakCanary则是由Square开源的一款轻量级的第三方内存泄漏检测工具，当检测到程序中产生内存泄漏时，它将以最直观的方式告诉我们哪里产生了内存泄漏和导致谁泄漏了而不能被回收。

由于单例的静态特性使得其生命周期和应用的生命周期一样长，如果一个对象已经不再需要使用了，而单例对象还持有该对象的引用，就会使得该对象不能被正常回收，从而导致了内存泄漏。

示例：防止单例导致内存泄漏的实例

这样不管传入什么Context最终将使用Application的Context，而单例的生命周期和应用的一样长，这样就防止了内存泄漏。？？？

例如，有时候我们可能会在启动频繁的Activity中，为了避免重复创建相同的数据资源，可能会出现如下写法：

这样在Activity内部创建了一个非静态内部类的单例，每次启动Activity时都会使用该单例的数据。虽然这样避免了资源的重复创建，但是这种写法却会造成内存泄漏。因为非静态内部类默认会持有外部类的引用，而该非静态内部类又创建了一个静态的实例，该实例的生命周期和应用的一样长，这就导致了该静态实例一直会持有该Activity的引用，从而导致Activity的内存资源不能被正常回收。

解决方法 ：将该内部类设为静态内部类或将该内部类抽取出来封装成一个单例，如果需要使用Context，就使用Application的Context。

示例：创建匿名内部类的静态对象

1、从Android的角度

当Android应用程序启动时，该应用程序的主线程会自动创建一个Looper对象和与之关联的MessageQueue。当主线程中实例化一个Handler对象后，它就会自动与主线程Looper的MessageQueue关联起来。所有发送到MessageQueue的Messag都会持有Handler的引用，所以Looper会据此回调Handle的handleMessage()方法来处理消息。只要MessageQueue中有未处理的Message，Looper就会不断的从中取出并交给Handler处理。另外，主线程的Looper对象会伴随该应用程序的整个生命周期。

2、 Java角度

在Java中，非静态内部类和匿名类内部类都会潜在持有它们所属的外部类的引用，但是静态内部类却不会。

对上述的示例进行分析，当MainActivity结束时，未处理的消息持有handler的引用，而handler又持有它所属的外部类也就是MainActivity的引用。这条引用关系会一直保持直到消息得到处理，这样阻止了MainActivity被垃圾回收器回收，从而造成了内存泄漏。

解决方法 ：将Handler类独立出来或者使用静态内部类，这样便可以避免内存泄漏。

示例：AsyncTask和Runnable

AsyncTask和Runnable都使用了匿名内部类，那么它们将持有其所在Activity的隐式引用。如果任务在Activity销毁之前还未完成，那么将导致Activity的内存资源无法被回收，从而造成内存泄漏。

解决方法 ：将AsyncTask和Runnable类独立出来或者使用静态内部类，这样便可以避免内存泄漏。

对于使用了BraodcastReceiver，ContentObserver，File，Cursor，Stream，Bitmap等资源，应该在Activity销毁时及时关闭或者注销，否则这些资源将不会被回收，从而造成内存泄漏。

1）比如在Activity中register了一个BraodcastReceiver，但在Activity结束后没有unregister该BraodcastReceiver。

2）资源性对象比如Cursor，Stream、File文件等往往都用了一些缓冲，我们在不使用的时候，应该及时关闭它们，以便它们的缓冲及时回收内存。它们的缓冲不仅存在于 java虚拟机内，还存在于java虚拟机外。如果我们仅仅是把它的引用设置为null，而不关闭它们，往往会造成内存泄漏。

3）对于资源性对象在不使用的时候，应该调用它的close()函数将其关闭掉，然后再设置为null。在我们的程序退出时一定要确保我们的资源性对象已经关闭。

4）Bitmap对象不在使用时调用recycle()释放内存。2.3以后的bitmap应该是不需要手动recycle了，内存已经在java层了。

初始时ListView会从BaseAdapter中根据当前的屏幕布局实例化一定数量的View对象，同时ListView会将这些View对象缓存起来。当向上滚动ListView时，原先位于最上面的Item的View对象会被回收，然后被用来构造新出现在下面的Item。这个构造过程就是由getView()方法完成的，getView()的第二个形参convertView就是被缓存起来的Item的View对象（初始化时缓存中没有View对象则convertView是null）。

构造Adapter时，没有使用缓存的convertView。

解决方法 ：在构造Adapter时，使用缓存的convertView。

我们通常把一些对象的引用加入到了集合容器（比如ArrayList）中，当我们不需要该对象时，并没有把它的引用从集合中清理掉，这样这个集合就会越来越大。如果这个集合是static的话，那情况就更严重了。

解决方法 ：在退出程序之前，将集合里的东西clear，然后置为null，再退出程序。

当我们不要使用WebView对象时，应该调用它的destory()函数来销毁它，并释放其占用的内存，否则其长期占用的内存也不能被回收，从而造成内存泄露。

解决方法 ：为WebView另外开启一个进程，通过AIDL与主线程进行通信，WebView所在的进程可以根据业务的需要选择合适的时机进行销毁，从而达到内存的完整释放。

1、在涉及使用Context时，对于生命周期比Activity长的对象应该使用Application的Context。凡是使用Context优先考虑Application的Context，当然它并不是万能的，对于有些地方则必须使用Activity的Context。对于Application，Service，Activity三者的Context的应用场景如下：

其中，NO1表示Application和Service可以启动一个Activity，不过需要创建一个新的task任务队列。而对于Dialog而言，只有在Activity中才能创建。除此之外三者都可以使用。

2、对于需要在静态内部类中使用非静态外部成员变量（如：Context、View )，可以在静态内部类中使用弱引用来引用外部类的变量来避免内存泄漏。

3、对于不再需要使用的对象，显示的将其赋值为null，比如使用完Bitmap后先调用recycle()，再赋为null。

4、保持对对象生命周期的敏感，特别注意单例、静态对象、全局性集合等的生命周期。

5、对于生命周期比Activity长的内部类对象，并且内部类中使用了外部类的成员变量，可以这样做避免内存泄漏：

1）将内部类改为静态内部类

2）静态内部类中使用弱引用来引用外部类的成员变量

Android内存泄漏总结

---