❶ 内存溢出和内存泄漏的区别产生原因以及解决方案。
内存溢出 out of memory，是指程序在申请内存时，没有足够的内存空间供其使用，出现out of memory；比如申请了一个integer,但给它存了long才能存下的数，那就是内存溢出。
内存泄露 memory leak，是指程序在申请内存后，无法释放已申请的内存空间，一次内存泄露危害可以忽略，但内存泄露堆积后果很严重，无论多少内存,迟早会被占光。
memory leak会最终会导致out of memory！
产生的原因：
1.内存中加载的数据量过于庞大，如一次从数据库取出过多数据；
2.集合类中有对对象的引用，使用键晌完后未清空，使得JVM不能回基慧收；
3.代码中存在死循环或循环产生过多重复的对象实体；
4.使用的第三方软件中的BUG；
5.启动参数内存值设定的过小
解决方案：
1）处理一些IO流的数据传输时，尽量结束时候把IO流关掉
2）处理下载照片时候，使用BitmapFactory.options。设置insameplesize（）方法压缩图片减少资源的占用；图片的压缩问题下面会写一个专门专题来讲；
3）还可以通过降低照片像素的方法，从而降低占用的内存
4）资源的回收：Bitmap.recycle（）bitmap=null;
5)尽量使用全局的变量，少new新的对象
❷ Android技术分享｜Android 中部分内存泄漏示例及解决方案
内存泄漏：
举例：
请注意以下的例子是虚构的
内存抖动
源自Android文档中的 Memory churn 一词，中文翻译为内存抖动。
指快速频繁的创建对象从而产生的性能问题。
引用Android文档原文：
Java内存泄漏的根本原因是 长生命周期 的对象持有 短生命周期 对象的引用就很可能发生内存泄漏。
尽管短生命周期对象已经不再需要，但因为长生命周期依旧持有它的引用，故不能被回收而导致内存泄漏。
静态集合类引起的内存泄漏
如果仅仅释放引用本身(tO = null)， ArrayList 依然在引用该对象，GC无法回收。
监听器
在Java应用中，通常会用到很多监听器，一般通过 addXXXXListener() 实现。但释放对象时通常会忘记删除监听器，从而增加内存泄漏的风险。
各种连接
如数据库连接、网络连接（Socket）和I/O连接。忘记显式调用 close() 方法引起的内存泄漏。
内部类和外部模块的引用
内部类的引用是很容易被遗忘的一种，一旦没有释放可能会导致一系列后续对象无法释放。此外还要小心外部模块不经意的引用，内部类是否提供相应的操作去除外部引用。
单例模式
由于单例的静态特性，使其生命周期与应用的生命周期一样长，一旦使用不恰当极易造成内存泄漏。如果单利持有外部引用，需要注意提供释放方式，否则当外部对象无法被正常回收时，会进而导致内存泄漏。
集合类泄漏
如集合的使用范围超过逻辑代码的范围，需要格外注意删除机制是否完善可靠。比如裂宽由静态属性 static 指向的集合。
单利泄漏
以下为简单逻辑代码，只为举例说明内存泄漏问题，不保证单利模式的可靠性。
AppManager 创建时需要传入一个 Context ，这个 Context 的生命周期长短至关重要。
1. 如果传入的是 Application 的 Context ，因为 Application 的生命周期等同于应用的生命周期，所以没有任何问山源清题。
2. 如果传入的是 Activity 的 Context ，则需要考虑这个 Activity 是否在整个生命周期都不会被回收了，如果不是，则会造成内存泄漏。
非静态内部类创建静态实例造成的内存泄漏
应该将该内部类单独封装为一个单例来使用。
匿名内部类/异步线程
Runnable都使用了匿名内部类，将持有MyActivity的引用。如果任务在Activity销毁前未完成，将导致Activity的内存无法被回收，从而造成内存泄漏。
解决方法：将Runnable独立逗前出来或使用静态内部类，可以避免因持有外部对象导致的内存泄漏。
Handler造成的内存泄漏
Handler属于TLS(Thread Local Storage)变量，生命周期与Activity是不一致的，容易导致持有的对象无法正确被释放
当Android应用程序启动时，该应用程序的主线程会自动创建一个Looper对象和与之关联的MessageQueue。
当主线程中实例化一个Handler对象后，它就会自动与主线程Looper的MessageQueue关联起来。所有发送到MessageQueue的Messag都会持有Handler的引用，所以Looper会据此回调Handle的handleMessage()方法来处理消息。只要MessageQueue中有未处理的Message，Looper就会不断的从中取出并交给Handler处理。
另外，主线程的Looper对象会伴随该应用程序的整个生命周期。
在Java中，非静态内部类和匿名类内部类都会潜在持有它们所属的外部类的引用，但是静态内部类却不会。
当该 Activity 被 finish() 掉时，延迟执行任务的 Message 还会继续存在于主线程中，它持有该 Activity 的 Handler 引用，所以此时 finish() 掉的 Activity 就不会被回收了从而造成内存泄漏（因 Handler 为非静态内部类，它会持有外部类的引用，在这里就是指 SampleActivity）。
避免不必要的静态成员变量
对于BroadcastReceiver、ContentObserver、File、Cursor、Stream、Bitmap等资源的使用，应在Activity销毁前及时关闭或注销。
不使用WebView对象时，应调用`destroy()`方法销毁。
❸ 内存泄漏、内存溢出
有一种情况下，oom可以通过try catch掉， 如果try catch语句中，声明了很大的对象导致OOM，并且确认OOM是由try语句中的对象声明导致的，那么在catch语句中，可以释放掉这些对象，解决OOM问题，继续执行剩余的语句。
上述做法不建议，毕竟catch掉异常，而不是想着解决OOM
Java中管理内存除了catch oom之外还有很多有效的方法，如SoftReference、WeakReference、硬盘缓存等。
在JVM用光内存之前，会多次触发GC，这些GC会降低程序运行的效率。
如果OOM原因不是try语句中对象（比如内存泄漏），那么在catch语句中会继续抛出OOM
在此可以了解一下内培败存泄漏和内存溢出的区别：
常发性、偶发性、一次性、隐式
怎样解决内存泄漏： 泄漏是因为持有了activity引用导致无法被销毁，一配并颤是及时取消引用蔽掘，二是让引用多待一会，但是该GC的时候就销毁
❹ 内存溢出和内存泄漏
内存溢出 out of memory，是指程序在申请内存时，没有足够的内存空间供其使用，出现out of memory；比如申请了一个integer,但给它存了long才能存下的数，那就是内存溢出。
内存泄露 memory leak，是指程序在申请内存后，无法释放已申请的内存空间，一次内存泄露危害可以忽略，但内存泄露堆积后果很严重，无论多少内存,迟早会被占光。
memory leak会最终会导致out of memory！
一，常见的内存溢出情况：
1，加载图片过大，超出所申请的内存
解决方法：
（1）对图片进行压缩处理（不推荐，图片多起来，你再怎么压缩也是要耗很大的内存）
（2）使用第三方加载图片框架（推荐，开源，省时又省事）Glide ,Picasso ,Fresco等
（3）减少Bitmap对象的引用，并及时的回收
2，对象引用没及时回收，导致堆积，超出所申请的内存
解决方法：
（1）动态回收内存
（2）对像引用采用软引用（方便内能够对此进行回收）
（3）对象复用，存在的对象不要重复多次new它，应该循环利用
（4）注意对象复用的生命周期（static和程序进程一样长）
（5）单例模式的合理使用，单例模式避免重复创建对象，但也注意他的生命周期和程序进程一样长容易因为持有的对象没有正常回收导致内存泄漏
（6）监听器不使用时及时注销
（7）尽量减少抽象对象的使用
3，页面持有内存，没有及时回收
（1）Activity，fragment页面：
（2）webview页面
4，无用服务后台持续运作，占用过多内存
（1）用完及时关闭
二，常见的内存泄漏情况：
1，Handler 引发内存泄漏
（1）handler发送的Message未被处理，那么该Message及发送它的Handler对象都会被线程一直持有，由于Handler属于TLS（Thread Local Storage）变量，生命周期和Activity是不一致的。如果Handler是我们的Activity类的非静态内部类，Handler就会持有Acitvity的强引用,此时该Activity退出时无法进行内存回收，造成内存泄漏。
解决方法：
将Handler声明为静态内部类和软引用，这样它就不会持有外部类的引用了，Handler的生命周期就与Activity无关了。声明时context采用Application的Context,销毁Acitvity时处理掉队列中的消息。
2，单例模式引发内存泄漏
（1）单例模式的静态属性，使它的生命周期和应用一样长，如果让单例引用Activity的强引用，Activity无法gc,就会导致内存泄漏。
解决方法：
所以在创建单例时，构造函数里对Activity 的context引用换成 ApplicationContext
3，匿名内部类引起内存泄漏
（1）activity ,fragment 或者view中使用匿名类，匿名类对象会持有Activity，Fragment，View的引用，如果引用传到异步线程中，异步线程和Activityt生命周期不一致的时候，就会造成Activity的泄漏。
解决方法：能直接声明内部类引用就减少匿名内部类的引用。尽量不把匿名内部类用到异步线程中去
4，WebView 引起的内存泄漏
（1）webview解析网页时会申请Natvie堆内存用于保存页面元素，当页面较复杂时，会有很大的内存占用。如果包含图片，内存占用会更严重，并且打开新页面时，为了能快速回退，之前页面内存也不会释放。或者是退出Activity页面时，webview还在处理网络数据，持有Activity的引用时会导致Activity不能被Gc也会造成内存泄漏。
解决方法：
webview采用动态添加，onDestroy时移除，和销毁webview。
5，集合引发的内存泄漏
（1）把对象的引用加入集合容器中，当我们不再需要该对象时，并没有把它的引用从集合中清理掉，当集合中的内容过大的时候，并且是static的时候就造成了内存泄漏。
解决方法：
在onDestory中清空；
6，其他引发内存泄漏
（1）构造Adapter时，没有使用缓存的convertView
（2）Bitmap在不使用的时候没有使用recycle()释放内存
（3）线程未终止造成内存泄漏
（4）对象的注册与反注册没有成对出现造成的内存泄漏；比如注册广播接收器，注册观察者等
（5）不要在执行频率很高的方法或者循环中创建对象。
本文整理自以下两篇文章
原文链接： https://blog.csdn.net/lililijunwhy/article/details/87966337
原文链接： https://blog.csdn.net/sasafeng/article/details/8559992
❺ 内存溢出的解决方法
内存溢出是指应用系统中存在无法回收的内存或使用的迹桐内存过多，最终使得程序运行要用到的内存大于虚拟机能提供的最大内存。
内存中加载的数据量过于庞大，如一次从数据库取出过多数如州卖据；集合类中有对对象的引用，使用完后未清空，使得JVM不能回渣逗收；代码中存在死循环或循环产生过多重复的对象实体；使用的第三方软件中的BUG；启动参数内存值设定的过小；
检查对数据库查询中，是否有一次获得全部数据的查询。一般来说，如果一次取十万条记录到内存，就可能引起内存溢出。这个问题比较隐蔽，在上线前，数据库中数据较少，不容易出问题，上线后，数据库中数据多了，一次查询就有可能引起内存溢出。因此对于数据库查询尽量采用分页的方式查询。
检查代码中是否有死循环或递归调用。
❻ 内存泄漏是什么
什么是内存泄漏?
一般我们常说的内存泄漏是指堆内存的泄漏。堆内存是指程序从堆中分配的，大小任意的工内存块的大小可以在程序运行期决定），使用完后必须显示释放的内存。应用程序一般使用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。
希望这个回答对你有帮助
❼ skynet网络层内存泄漏
Skynet是一种旨在轻量级并为多人游戏提供服务的网络框架。在使用Skynet的过程中，可能会遇到内存泄漏的问题。下面是一些可能导致Skynet网络层内存泄漏的原因和解决方法：
1. 长时间运行的服务
一些服务可能会持续很长时间，如果这些服务创建了一些内容，则这些内容会一直占用内存。因此，需要在服务完成后清理它们分配的内存。可以通过在服务初始化时分配一个内存池来解决这个问题，在服务完成时释放内存池。
2. 没有正确处理消息
Skynet使用异步消息传递来处理协作操作，如果服务没有正确处理消息，则内存可能会泄漏。在处理消息时，需要记住释放不再使用的内存，例如在发送消息之前动态分配内存，或在调用回调函数之后动态分配内存。
3. 协作操作泄漏
在使用Skynet的时候，可能会发生一些协作操作，例如发送消息、注册timer等等，如果没有正确处理这些事件，可能会导致内存泄漏。因此，在使用Skynet时，需要确保正确处理这些协作操作，并在用完之后及时释放相关内存斗皮亮。
4. 跨服务的共享内存
在Skynet中，有时需要在多个服务之间共享内存。如果这些共享内存没握烂有正确管理，则可能会导致内存泄漏。因此，在实现跨服务共享内存时，需要确保使用内存池，并在使用之后及时释放内存。
总而言之，要避免Skynet网络层内存泄漏，需要注意在服务初始化和结束时分配和释放内空宽存、正确处理消息和协作操作、使用内存池并在使用之后及时释放内存。
❽ 常见的内存泄漏原因及解决方法
（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内存泄漏总结
❾ 什么是内存泄露内存泄露该如何解决
1、内存泄漏指由于疏忽或错误造成程序未能释放已经不再使用的内存的情况。
2、一般我们常说的内存泄漏是指堆内存的泄漏。堆内存是指程序从堆中分配的，大小任意的，
使用完后必须显式释放的内存。应用程序一般使用malloc，calloc，realloc，new等函数从堆
中分配到一块内存，使用完后，程序必须负责相应的调用free或delete释放该内存块，否则
这块内存就不能被再次使用，就是这块内存泄漏了。
3、内存泄露多数属于程序本身设计问题，有以下几种解决方法：
1）从程序内部重新编译。养成良好的编码习惯，尽量在涉及内存的程序段，检测出内存泄露。
2）结束程序，内存自然就会被操作系统回收。
3）重新启动电脑后，立刻恢复。
❿ threadlocal内存泄漏原因和解决方案
首先是因为 ThreadLocal 是基于 ThreadLocalMap 实现的，其中 ThreadLocalMap 的 Entry 继承了 WeakReference ，而 Entry 对象中的 key 使用了 WeakReference 封装，也就是说， Entry 中的 key 是一个弱引用类型，对于弱引用来说，它只能存活到下次 GC 之前 ;如果此时一个线程调用了 ThreadLocalMap 的 set 设置变量，当前的 ThreadLocalMap 就会新增一条记录，但由于发生了一次垃圾回收，这样就会造游陵喊成一个结果: key 值被回收掉了，但神野是 value 值还在内存中，而且如果线程一直存在的话，那么它的 value 值就会一直存在
可知是汪凳因为value 值没有被回收掉导致内存泄露,使用完 key 值之后，将 value 值通过 remove 方法 remove 掉，也就防止了内存泄漏
参考文章 https://m.html.cn/softprog/java/66005.html