内存泄漏原因解析Word下载.docx
《内存泄漏原因解析Word下载.docx》由会员分享，可在线阅读，更多相关《内存泄漏原因解析Word下载.docx（31页珍藏版）》请在冰豆网上搜索。
对象无用了，但仍然可达（未释放），垃圾回收器无法回收。
三、内存泄漏有什么危害？
内存泄漏对于app没有直接的危害，即使app有发生内存泄漏的情况，也不一定会引起app崩溃，但是会增加app内存的占用。
内存得不到释放，慢慢的会造成app内存溢出。
所以我们解决内存泄漏的目的就是防止app发生内存溢出。
四、其中内存泄漏产生的实例原因：
1.静态变量引起的内存泄漏
在java中静态变量的生命周期是在类加载时开始，类卸载时结束。
换句话说，在android中其生命周期是在进程启动时开始，进程死亡时结束。
所以在程序的运行期间，如果进程没有被杀死，静态变量就会一直存在，不会被回收掉。
如果静态变量强引用了某个Activity中变量，那么这个Activity就同样也不会被释放,即便是该Activity执行了onDestroy（不要将执行onDestroy和被回收划等号）。
解决办法：
1.寻找与该静态变量生命周期差不多的替代对象。
2.若找不到，将强引用方式改成弱引用。
在Activity被静态变量引用时，使用getApplicationContext因为Application生命周期从程序开始到结束，和static变量的一样。
单例引起的Context内存泄漏
publicclassIMManager{
privateContextcontext;
privatestaticIMManagermInstance;
publicstaticIMManagergetInstance（Contextcontext）{
if（mInstance==null）{
synchronized（IMManager.class）{
if（mInstance==null）
mInstance=newIMManager（context）;
}
returnmInstance;
}
privateIMManager（Contextcontext）{
this.context=context;
当调用getInstance时，如果传入的context是Activity的context。
只要这个单例没有被释放，这个Activity也不会被释放。
解决方案
传入Application的context,因为Application的context的生命周期比Activity长，可以理解为Application的context与单例的生命周期一样长，传入它是最合适的。
//将传入的context转换成Application的context
mInstance=newIMManager（context.getApplicationContext（））;
2.非静态内部类引起的内存泄漏
在java中，创建一个非静态的内部类实例，就会引用它的外围实例。
如果这个非静态内部类实例做了一些耗时的操作，就会造成外围对象不会被回收，从而导致内存泄漏。
1.将内部类变成静态内部类
2.如果有强引用Activity中的属性，则将该属性的引用方式改为弱引用。
因为弱引用只要GC发现了就会回收它，因此可尽快回收
3.在业务允许的情况下，当Activity执行onDestory时，结束这些耗时任务。
内部线程造成的内存泄漏
publicclassLeakAtyextendsActivity{
@Override
protectedvoidonCreate（BundlesavedInstanceState）{
super.onCreate（savedInstanceState）;
setContentView（R.layout.aty_leak）;
test（）;
publicvoidtest（）{
//匿名内部类会引用其外围实例LeakAty.this,所以会导致内存泄漏
newThread（newRunnable（）{
publicvoidrun（）{
while（true）{
try{
Thread.sleep（1000）;
}catch（InterruptedExceptione）{
e.printStackTrace（）;
}）.start（）;
将非静态匿名内部类修改为静态匿名内部类
//加上static，变成静态匿名内部类
publicstaticvoidtest（）{
Handler的使用造成的内存泄漏
由于在Handler的使用中，handler会发送message对象到MessageQueue中然后Looper会轮询MessageQueue然后取出Message执行，但是如果一个Message长时间没被取出执行，那么由于Message中有Handler的引用，而Handler一般来说也是内部类对象，Message引用Handler，Handler引用Activity这样使得Activity无法回收。
依旧使用静态内部类+弱引用的方式可解决.
publicclassLeakAtyextendsActivity{
fetchData（）;
privateHandlermHandler=newHandler（）{
publicvoidhandleMessage（android.os.Messagemsg）{
switch（msg.what）{
case0:
//刷新数据
break;
default:
};
privatevoidfetchData（）{
//获取数据
mHandler.sendEmptyMessage（0）;
mHandler为匿名内部类实例，会引用外围对象LeakAty.this,如果该Handler在Activity退出时依然还有消息需要处理，那么这个Activity就不会被回收。
解决方案
privateTextViewtvResult;
privateMyHandlerhandler;
tvResult=（TextView）findViewById（R.id.tvResult）;
handler=newMyHandler（this）;
//第一步，将Handler改成静态内部类。
privatestaticclassMyHandlerextendsHandler{
//第二步，将需要引用Activity的地方，改成弱引用。
privateWeakReference<
LeakAty>
atyInstance;
publicMyHandler（LeakAtyaty）{
this.atyInstance=newWeakReference<
（aty）;
publicvoidhandleMessage（Messagemsg）{
super.handleMessage（msg）;
LeakAtyaty=atyInstance==null?
null:
atyInstance.get（）;
//如果Activity被释放回收了，则不处理这些消息
if（aty==null||aty.isFinishing（））{
return;
aty.tvResult.setText（"
fetchdatasuccess"
）;
//获取数据
handler.sendEmptyMessage（0）;
protectedvoidonDestroy（）{
//第三步，在Activity退出的时候移除回调
super.onDestroy（）;
handler.removeCallbacksAndMessages（null）;
AsyncTask造成内存泄漏
packagecom.myapplication;
importandroid.os.AsyncTask;
importandroid.support.v7.app.AppCompatActivity;
importandroid.os.Bundle;
importandroid.util.Log;
importandroid.view.View;
publicclassActivity2extendsAppCompatActivity{
setContentView（R.layout.activity_2）;
findViewById（R.id.finish2）.setOnClickListener（newView.OnClickListener（）{
publicvoidonClick（Viewv）{
finish（）;
}）;
newAsyncTask<
String,Integer,String>
（）{
protectedStringdoInBackground（String...params）{
Thread.sleep（6000）;
return"
ssss"
;
protectedvoidonPostExecute（Strings）{
super.onPostExecute（s）;
Log.d（"
mmmmmmactivity2"
"
"
+s）;
}.executeOnExecutor（AsyncTask.THREAD_POOL_EXECUTOR,"
）;
为什么？
上面代码在activity中创建了一个匿名类AsyncTask，匿名类和非静态内部类相同，会持有外部类对象，这里也就是activity，因此如果你在Activity里声明且实例化一个匿名的AsyncTask对象，则可能会发生内存泄漏，如果这个线程在Activity销毁后还一直在后台执行，那这个线程会继续持有这个Activity的引用从而不会被GC回收，直到线程执行完成。
怎么解决？
自定义静态AsyncTask类A
syncTask的周期和Activity周期保持一致。
也就是在Activity生命周期结束时要将AsyncTaskcancel掉。
?
.myapplication;
publicclassAsyncTaskActivityextendsAppCompatActivity{
privatestaticMyTaskmyTask;
setContentView（R.layout.activity_asynctask）;
findViewById（R.id.finish）.setOnClickListener（newView.OnClickListener（）{
myTask=newMyTask（）;
myTask.executeOnExecutor（AsyncTask.THREAD_POOL_EXECUTOR,"
privatestaticclassMyTaskextendsAsyncTask{
protectedObjectdoInBackground（Object[]params）{
//模拟耗时操作
Thread.sleep（15000）;
//取消异步任务
if（myTask!
=null）{
myTask.cancel（true）;
TimerTasks造成内存泄漏
importjava.util.Timer;
importjava.util.TimerTask;
publicclassTimerActivityextendsAppCompatActivity{
//开始定时任务
timer（）;
voidtimer（）{
newTimer（）.schedule（newTimerTask（）{
while（true）;
},1000）;
//1秒后启动一个任务
为什么？
这里内存泄漏在于Timer和TimerTask没有进行Cancel，从而导致Timer和TimerTask一直引用外部类Activity。
怎么解决？
在适当的时机进行Cancel。
TimerTask用静态内部类
注意：
在网上看到一些资料说，解决TimerTask内存泄漏可以使用在适当的时机进行Cancel。
经过测试，证明单单使用在适当的时机进行Cancel，还是有内存泄漏的问题。
所以一定要用静态内部类配合使用。
publicclassTimerActivityextendsAppCompatActivity{
privateTimerTasktimerTask;
findVie
升级会员 