个人中心
gpt4 book ai didi

Android内存泄漏终极解决篇（下）

转载 作者：qq735679552 更新时间：2022-09-28 22:32:09 25 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章Android内存泄漏终极解决篇（下）由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

1、概述 。

在 Android内存泄漏终极解决篇（上）中我们介绍了如何检查一个App是否存在内存泄漏的问题，本篇将总结典型的内存泄漏的代码，并给出对应的解决方案。内存泄漏的主要问题可以分为以下几种类型:

  • 静态变量引起的内存泄漏
  • 非静态内部类引起的内存泄漏
  • 资源未关闭引起的内存泄漏

2、静态变量引起的内存泄漏 。

在java中静态变量的生命周期是在类加载时开始，类卸载时结束。换句话说，在android中其生命周期是在进程启动时开始，进程死亡时结束。所以在程序的运行期间，如果进程没有被杀死，静态变量就会一直存在，不会被回收掉。如果静态变量强引用了某个Activity中变量，那么这个Activity就同样也不会被释放,即便是该Activity执行了onDestroy(不要将执行onDestroy和被回收划等号)。这类问题的解决方案为：1.寻找与该静态变量生命周期差不多的替代对象。2.若找不到，将强引用方式改成弱引用。比较典型的例子如下

单例引起的Context内存泄漏 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class IMManager {
   private Context context;
   private static IMManager mInstance;
 
   public static IMManager getInstance(Context context) {
     if (mInstance == null ) {
       synchronized (IMManager. class ) {
         if (mInstance == null )
           mInstance = new IMManager(context);
       }
     }
     return mInstance;
   }
 
   private IMManager(Context context) {
     this .context = context;
   }
 
}

当调用getInstance时，如果传入的context是Activity的context。只要这个单例没有被释放，这个Activity也不会被释放.

解决方案 传入Application的context,因为Application的context的生命周期比Activity长，可以理解为Application的context与单例的生命周期一样长，传入它是最合适的.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class IMManager {
   private Context context;
   private static IMManager mInstance;
 
   public static IMManager getInstance(Context context) {
     if (mInstance == null ) {
       synchronized (IMManager. class ) {
         if (mInstance == null )
           //将传入的context转换成Application的context
           mInstance = new IMManager(context.getApplicationContext());
       }
     }
     return mInstance;
   }
 
   private IMManager(Context context) {
     this .context = context;
   }
 
}

3、非静态内部类引起的内存泄漏 。

在java中，创建一个非静态的内部类实例，就会引用它的外围实例。如果这个非静态内部类实例做了一些耗时的操作，就会造成外围对象不会被回收，从而导致内存泄漏。这类问题的解决方案为：1.将内部类变成静态内部类 2.如果有强引用Activity中的属性，则将该属性的引用方式改为弱引用。3.在业务允许的情况下，当Activity执行onDestory时，结束这些耗时任务.

内部线程造成的内存泄漏 。

?
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
public class LeakAty extends Activity {
 
   @Override
   protected void onCreate(Bundle savedInstanceState) {
     super .onCreate(savedInstanceState);
     setContentView(R.layout.aty_leak);
     test();
   }
 
   public void test() {
     //匿名内部类会引用其外围实例LeakAty.this,所以会导致内存泄漏
     new Thread( new Runnable() {
 
       @Override
       public void run() {
         while ( true ) {
           try {
             Thread.sleep( 1000 );
           } catch (InterruptedException e) {
             e.printStackTrace();
           }
         }
       }
     }).start();
   }
   }

解决方案 将非静态匿名内部类修改为静态匿名内部类 。

?
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
public class LeakAty extends Activity {
 
   @Override
   protected void onCreate(Bundle savedInstanceState) {
     super .onCreate(savedInstanceState);
     setContentView(R.layout.aty_leak);
     test();
   }
   //加上static，变成静态匿名内部类
   public static void test() {
     new Thread( new Runnable() {
 
       @Override
       public void run() {
         while ( true ) {
           try {
             Thread.sleep( 1000 );
           } catch (InterruptedException e) {
             e.printStackTrace();
           }
         }
       }
     }).start();
   }
}

Handler引起的内存泄漏 。

?
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
public class LeakAty extends Activity {
 
   @Override
   protected void onCreate(Bundle savedInstanceState) {
     super .onCreate(savedInstanceState);
     setContentView(R.layout.aty_leak);
     fetchData();
 
   }
 
   private Handler mHandler = new Handler() {
     public void handleMessage(android.os.Message msg) {
       switch (msg.what) {
       case 0 :
         // 刷新数据
         break ;
       default :
         break ;
       }
 
     };
   };
 
   private void fetchData() {
     //获取数据
     mHandler.sendEmptyMessage( 0 );
   }
}

mHandler 为匿名内部类实例，会引用外围对象LeakAty.this,如果该Handler在Activity退出时依然还有消息需要处理，那么这个Activity就不会被回收.

解决方案 。

  。

?
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
public class LeakAty extends Activity {
   private TextView tvResult;
   private MyHandler handler;
 
   @Override
   protected void onCreate(Bundle savedInstanceState) {
     super .onCreate(savedInstanceState);
     setContentView(R.layout.aty_leak);
     tvResult = (TextView) findViewById(R.id.tvResult);
     handler = new MyHandler( this );
     fetchData();
 
   }
   //第一步，将Handler改成静态内部类。
   private static class MyHandler extends Handler {
     //第二步，将需要引用Activity的地方，改成弱引用。
     private WeakReference<LeakAty> atyInstance;
     public MyHandler(LeakAty aty) {
       this .atyInstance = new WeakReference<LeakAty>(aty);
     }
 
     @Override
     public void handleMessage(Message msg) {
       super .handleMessage(msg);
       LeakAty aty = atyInstance == null ? null : atyInstance.get();
       //如果Activity被释放回收了，则不处理这些消息
       if (aty == null ||aty.isFinishing()) {
         return ;
       }
       aty.tvResult.setText( "fetch data success" );
     }
   }
 
   private void fetchData() {
     // 获取数据
     handler.sendEmptyMessage( 0 );
   }
 
   @Override
   protected void onDestroy() {
     //第三步，在Activity退出的时候移除回调
     super .onDestroy();
     handler.removeCallbacksAndMessages( null );
   }
}

4、资源未关闭引起的内存泄漏 。

当使用了BraodcastReceiver、Cursor、Bitmap等资源时，当不需要使用时，需要及时释放掉，若没有释放，则会引起内存泄漏.

综上所述，内存泄漏的主要情况为上面的三大类型，最终归结为一点，就是资源在不需要的时候没有被释放掉。所以在编码的过程中要注意这些细节，提高程序的性能.

最后此篇关于Android内存泄漏终极解决篇（下）的文章就讲到这里了,如果你想了解更多关于Android内存泄漏终极解决篇（下）的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

25 4 0
文章推荐： 实例详解Android文件存储数据方式
文章推荐： SpringBoot项目部署在weblogic中间件的注意事项说明
文章推荐： Java之SpringBean生命周期问题理解
文章推荐： @RequestBody时第二个字母大写,映射不到的解决
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com