Android爱好者程序员

android 内存泄漏分析与优化（二）

2016-06-23  本文已影响172人  qiaoStr

内存抖动、内存溢出、内存泄漏

public final class MainActivity extends Activity
 { 
    private DbManager mDbManager; 
    @Override
    protected void onCreate(Bundle savedInstanceState) 
     { 
       super.onCreate(savedInstanceState); 
       setContentView(R.layout.activity_main); 
       //DbManager是一个单例模式类，这样就持有了              
        //MainActivity引用，导致泄露 
     mDbManager = DbManager.getInstance(this); 
    }
}

分析：由于单例的静态特性使得它的生命周期比较长，又因为它持有activity，所以当activity退出时，此activity得不到GC回收从而导致了内存泄漏。

举例二：集合中

Vector v = new Vector(10);
for (int i = 1; i < 100; i++) 
{ 
    Object o = new Object(); 
     v.add(o);
     o = null; 
}

分析：
在这个例子中，我们循环申请Object对象，并将所申请的对象放入一个 Vector 中，如果我们仅仅释放引用本身，那么 Vector 仍然引用该对象，所以这个对象对 GC 来说是不可回收的。因此，如果对象加入到Vector 后，还必须从 Vector 中删除，最简单的方法就是将 Vector 对象设置为 null。

Android中常见的内存泄漏汇总以及相应的解决办法

  public class AppManager 
 { 
     private static AppManager instance; 
     private Context context;
     private AppManager(Context context)
     {
       this.context = context; 
     } 
   public static AppManager getInstance(Context context) 
   { 
      if (instance == null) 
          {
            instance = new AppManager(context);
          } 
       return instance; 
   } 
}

分析：这是一个普通的单例模式，当创建这个单例的时候，由于需要传入一个Context，所以这个Context的生命周期的长短至关重要，如果此时传入的是 Application 的 Context，因为Application 的生命周期就是整个应用的生命周期，所以这将没有任何问题。如果此时传入的是 Activity 的 Context，当这个 Context 所对应的 Activity 退出时，由于该 Context 的引用被单例对象所持有，其生命周期等于整个应用程序的生命周期，所以当前 Activity 退出时它的内存并不会被回收，这就造成泄漏了。

正确的方式应该改为下面这种方式：

public class AppManager
{ 
   private static AppManager instance; 
   private Context context;
   private AppManager(Context context) 
    { 
      this.context = context.getApplicationContext(); 
    }
   public static AppManager getInstance(Context context)
    { 
        if (instance == null) 
    {
       instance = new AppManager(context);
    } 
      return instance; 
    } 
 }

public class MainActivity extends Activity 
{
...
Runnable ref1 = new MyRunable();
Runnable ref2 = new Runnable() 
{ 
@Override
 public void run()
 {
 }
};
 ...
}

分析：匿名内部类是默认持有外部的引用，因此容易造成内存泄漏。

举个栗子：


public class SampleActivity extends Activity 
{ 
    private final Handler mLeakyHandler = new Handler()
    { 
      @Override 
         public void handleMessage(Message msg) 
           { 
          // ...
           } 
   } 
     @Override 
  protected void onCreate(Bundle savedInstanceState)
     { 
       super.onCreate(savedInstanceState); // Post a message and delay its execution for 10 minutes. 
       mLeakyHandler.postDelayed(new Runnable() 
         { 
             @Override
            public void run() 
            { 
                  /* ... */
            } 
         }, 1000 * 60 * 10); // Go back to the previous Activity. 
      
     finish();
    } 
}

分析：
在该 SampleActivity 中声明了一个延迟10分钟执行的消息 Message，mLeakyHandler 将其 push 进了消息队列 MessageQueue 里。当该 Activity 被 finish() 掉时，延迟执行任务的 Message 还会继续存在于主线程中，它持有该 Activity 的 Handler 引用，所以此时 finish() 掉的 Activity 就不会被回收了从而造成内存泄漏（因 Handler 为非静态内部类，它会持有外部类的引用，在这里就是指 SampleActivity）。

修复方法：
在 Activity 中避免使用非静态内部类，比如上面我们将 Handler 声明为静态的，则其存活期跟 Activity 的生命周期就无关了。同时通过弱引用的方式引入 Activity，避免直接将 Activity 作为 context 传进去，见下面代码：


public class SampleActivity extends Activity 
{ 
/** * Instances of static inner classes do not hold an implicit * reference to their outer class. */ 
private static class MyHandler extends Handler
{ 
    private final WeakReference<SampleActivity> mActivity; 
    public MyHandler(SampleActivity activity) 
     { 
        mActivity = new WeakReference<SampleActivity>(activity); 
     }
    @Override 
     public void handleMessage(Message msg) 
    { 
        SampleActivity activity = mActivity.get();
       if (activity != null) 
          { 
             // ... 
          } 
     } 
} 
private final MyHandler mHandler = new MyHandler(this); 
/** * Instances of anonymous classes do not hold an implicit * reference to their outer class when they are "static". */
 private static final Runnable sRunnable = new Runnable() 
  { 
     @Override 
      public void run()
       {
           /* ... */
       } 
  }; 
 @Override 
protected void onCreate(Bundle savedInstanceState)
 { 
super.onCreate(savedInstanceState); // Post a message and delay its execution for 10 minutes. 
mHandler.postDelayed(sRunnable, 1000 * 60 * 10); // Go back to the previous Activity. 
finish();
 }
}

综述，即推荐使用静态内部类 + WeakReference 这种方式。每次使用前注意判空。

上一篇 下一篇

猜你喜欢

热点阅读