关闭

Android 内存优化

标签: android内存优化
53人阅读 评论(0) 收藏 举报
分类:

Android发生内存泄漏最普遍的一种情况就是长期保持对Context,特别是Activity的引用,使得Activity无法被销毁。这也就意味着Activity中所有的成员变量也没办法销毁。本文仅介绍如何避免这种情况的发生,其他如Bitmap没有及时回收导致的OOM异常暂不讨论。

一、防止内存泄漏

什么情况下会长时间保持对某个Activity的引用呢?主要有以下两种情况:

1、某个static变量保持对Activity的引用

2、线程保持Activity的引用

由于静态变量是长驻内存的,甚至在你调用了exit方法后仍不会被销毁。而线程的生命周期是无法预料的。一旦发生了切屏,Activity就无法被销毁。下面来看一个简单的例子:

  1. public class MainActivity extends Activity { 
  2.  
  3.     @Override 
  4.     protected void onCreate(Bundle savedInstanceState) { 
  5.         super.onCreate(savedInstanceState); 
  6.         setContentView(R.layout.activity_main); 
  7.     } 
  8.      
  9.     public void onClick(View v){ 
  10.         new MyThread().start(); 
  11.     } 
  12.      
  13.     class MyThread extends Thread{ 
  14.         public void run(){ 
  15.             try
  16.                 Thread.sleep(60000); 
  17.             } catch (InterruptedException e) { 
  18.                 // TODO Auto-generated catch block 
  19.                 e.printStackTrace(); 
  20.             } 
  21.         } 
  22.     } 
线程MyThread是Activity的内部类,这有什么问题呢?我们知道,内部类是会持有外部类的引用的,这就是上面说到的第二种情况。那么怎么优化,使线程不持有Activity的引用呢?熟悉Java的马上就会想到静态内部类,没错,只要在定义MyThread的时候加一个static,这样这个内部类就不会持有外部类的引用了。

然而在实际应用中,线程的问题往往要比这复杂很多。我们可能还要用到AsyncTask或者Handler加Thread来异步获取数据并刷新界面。此时如果只是简单的将AsyncTask或者Handler定义成静态的,那么无法实现刷新界面的功能。之前的做法是使用弱引用(WeakReference),但是2.3以后的Android加强了对弱引用及软引用的回收,如果在内存不是很足的情况下,很可能导致你的引用过早被系统回收,而无法做刷新界面的操作。接下来的这个例子将提供一种新的解决方案:

  1. public class MainActivity extends Activity { 
  2.     private MyThread t; 
  3.     private String TAG = "tag"
  4.  
  5.     @Override 
  6.     protected void onCreate(Bundle savedInstanceState) { 
  7.         super.onCreate(savedInstanceState); 
  8.         setContentView(R.layout.activity_main); 
  9.     } 
  10.      
  11.     @Override 
  12.     protected void onDestroy() { 
  13.         if(t != null){ 
  14.             t.detach(); 
  15.         } 
  16.         super.onDestroy(); 
  17.     } 
  18.      
  19.     public void onClick(View v){ 
  20.         if(t != null){ 
  21.             t.detach(); 
  22.         } 
  23.         t = new MyThread(); 
  24.         Callback callback = new Callback(){ 
  25.  
  26.             @Override 
  27.             public void finish() { 
  28.                 Log.v(TAG, "finish"); 
  29.             } 
  30.              
  31.         }; 
  32.         t.attach(callback); 
  33.         t.start(); 
  34.     } 
  35.      
  36.     static interface Callback{ 
  37.         void finish(); 
  38.     } 
  39.      
  40.     static class MyThread extends Thread { 
  41.         Callback callback; 
  42.          
  43.         void attach(Callback callback){ 
  44.             this.callback = callback; 
  45.         } 
  46.          
  47.         void detach(){ 
  48.             if(callback != null){ 
  49.                 callback = null
  50.             } 
  51.         } 
  52.          
  53.         public void run(){ 
  54.             try
  55.                 Thread.sleep(60000); 
  56.             } catch (InterruptedException e) { 
  57.                 // TODO Auto-generated catch block 
  58.                 e.printStackTrace(); 
  59.             } 
  60.             if(callback != null){ 
  61.                 callback.finish(); 
  62.             } 
  63.         } 
  64.     } 
第二个例子在第一个例子的基础上加了回调,如果是用AsyncTask或者Handler的话,可以在回调内做更新界面的操作。最关键的部分在于线程的detach方法,它将持有Activity引用的回调成员置空。那么我们只要保证在Activity被销毁前,所有持有该引用的变量都能被置空,这样,长时间持有Activity引用的条件也就不成立了。所以可以看到在Activity的onDestroy方法和new一个线程之前,都要将现有线程的回调置空。

二、使用MAT检测内存泄漏

MAT是eclipse的内存分析工具。接下来我会从安装开始,并结合上面的例子来简单介绍一下如何使用这个工具。

1、安装

Help--> Install New Software --> Add,链接是http://download.eclipse.org/mat/1.3/update-site/,最好要勾选“Contact all update sites...”这个选项,不然你的eclipse可能没有这个插件依赖的一些包。点击确定就等它龟速下载吧。安装完之后重启eclipse就可以用了。

2、使用

这个工具可以结合DDMS来用。先将我们的程序跑起来,然后打开DDMS,选择要分析的程序,点击Dump HPROF File按钮,稍等片刻就可以看到内存的详细使用情况了。


3、结合上面的例子分析

我们首先看一下不置空回调的情况,把ondestroy和new线程那部分代码注释掉。运行程序之后打开DDMS,并开启Update Heap(为了能使用GC)和Update Thread(查看线程)。之后我们运行线程,并切换横屏,如下图:

可以看到此时多了一个线程(图中ID为9)。打开MAT,点击"Open Dominator Tree for entrie heap",最后再点开“Show as Histogram”,在这里就可以查看我们各个类的引用情况了。如下图:

可以看到此时的MainActivity有两个引用。返回到DDMS,点击“Cause GC”(那个垃圾桶图标),打开新的MAT,继续找MainActivity,如果没有意外出现的话,MainActivity的引用仍为2,也就是说,并没有回收前一个Activity。

但是如果取消刚才的注释,同样的操作,点击GC之后,发现MainActivity的引用又变回1了。

注意:以上操作最好在线程执行完毕之前完成,不熟悉的可以将线程执行时间设置长一些来看效果。

三、建议

1、尽量不要长时间保持Activity的引用。

2、尝试用Application的context来代替Activity的context。因为Application是存在于程序的整个生命周期的,不像Activity一样随时有可能被销毁。

3、避免使用静态的持有Activity引用的成员变量,巧妙使用静态内部类。

4、适当运用弱引用。

5、如果确实需要保持对Activity的引用,必须确保在Activity的生命周期结束前,取消该引用。

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:251次
    • 积分:44
    • 等级:
    • 排名:千里之外
    • 原创:4篇
    • 转载:2篇
    • 译文:0篇
    • 评论:0条
    文章分类
    文章存档