内存优化(二)如何避免内存泄漏

一、不同生命周期导致的内存泄漏

前面有分析了内存泄漏的原因,本该被回收的对象被占用,得不到回收便会内存泄漏。总归到底的原因还是对象引用在类之间传递,它们的生命周期不同,导致回收时发生问题。

举个简单的例子:

当单列模式中传入的Activity是,ToastRouter便持有了MainActivity的强引用,当MainActivity结束时,便得不到回收,这是内存泄漏发生了

public class MainActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ToastRouter.getInstance(this);
    }
}


...


public class ToastRouter {
    private static final ToastRouter ourInstance = new ToastRouter();
    private Context mContext;

    public static ToastRouter getInstance(Context context) {
        this.mContext=context;
        return ourInstance;
    }

    private ToastRouter() {
    }

}

解决办法

  • 尽量避免生命周期不对等的对象引用传递,如果避免不了,应用对等生命周期的对象替代。如上Activity传入,可以用ApplicationContext传递代替,因为ApplicationContext的生命周期与APP对等。
  • 与对象生命周期绑定释放,如上例子,应该在MainActivity onDestary()方法中释放传入对象引用

二、非静态内部类持有对象导致的内存泄漏

非静态内部类持有对象导致的内存泄漏也很好理解,就是内部类持有了外部类的对象,导致的外部类回收失败造成的内存泄漏

1. 非静态内部类调用外部类的方法的

  • 看一个简单的JAVA代码案例
    • 通过匿名内部类,内部类分别打印一个延时log日志。
    • 其中分别用的AsyncTask和Handler举例
        /**
         * 通过匿名内部类,打印一个1.5s延时log
         */
        public void doAnonymousInnerClassTask() {
            new AsyncTask() {
                @Override
                protected Void doInBackground(Void... voids) {
                    //睡眠1.5s
                    try {
                        Thread.sleep(1500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    logMsg(" AsyncTask 匿名内部类 doInBackground");
                    return null;
                }
            }.execute();
        }
    
        /**
         * 通过内部类,打印一个1.5s延时log
         */
        public void doNormalInnerTask() {
            TestAsyncTask testAsyncTask = new TestAsyncTask();
            testAsyncTask.execute();
        }
        
        private class TestAsyncTask extends AsyncTask {
    
            @Override
            protected Void doInBackground(Void... voids) {
    
                try {
                    Thread.sleep(1500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                logMsg(" TestAsyncTask内部类 doInBackground");
                return null;
            }
        }
        
        private void logMsg(String msg) {
            Log.d(TAG, msg);
        }
  • 我们通过.class文件,查看它的对象引用发现,在匿名内部类和内部类中,调用MainActivity的logMsg方法时,已持有了MainActivity.this的引用,因此当非静态内部类生命周期比MainActivity长时,即发生了内存泄漏。

      public void doAnonymousInnerClassTask() {
          (new AsyncTask() {
              protected Void doInBackground(Void... voids) {
                  try {
                      Thread.sleep(1500L);
                  } catch (InterruptedException var3) {
                      var3.printStackTrace();
                  }
    
                  MainActivity.this.logMsg(" AsyncTask 匿名内部类 doInBackground");
                  return null;
              }
          }).execute(new Void[0]);
      }
    
      private class TestAsyncTask extends AsyncTask {
          private TestAsyncTask() {
          }
    
          protected Void doInBackground(Void... voids) {
              try {
                  Thread.sleep(1500L);
              } catch (InterruptedException var3) {
                  var3.printStackTrace();
              }
    
              MainActivity.this.logMsg(" TestAsyncTask内部类 doInBackground");
              return null;
          }
      }
    

2. 内部类是如何持有外部类对象?

上述通过.class文件可以看到内部类在调用外部类的方法时,通过持有的外部类对象去调用。那么外部类对象的引用是什么时候传入的呢。通过
参考文章:深入理解Java中为什么内部类可以访问外部类的成员得到结论:

  • 编译器自动为内部类添加一个成员变量, 这个成员变量的类型和外部类的类型相同, 这个成员变量就是指向外部类对象的引用;
  • 编译器自动为内部类的构造方法添加一个参数, 参数的类型是外部类的类型, 在构造方法内部使用这个参数为1中添加的成员变量赋值;
  • 在调用内部类的构造函数初始化内部类对象时, 会默认传入外部类的引用。

由此,即使内部类并没有调用外部类的方法或者变量,也一样会持有外部类的引用。

3. 如何处理非静态内部类内存泄漏问题

  1. 可以使用,但是前提是确保非静态内部类的生命周期超过外部类

  2. 使用静态内部类,在静态内部类需要持有外部类引用时,通过关联外部类的弱引用去调用。

     /**
      * 通过静态内部类打印一个1.5s延时log
      */
     public void doStaticInnerClassTask() {
         mHandler.sendEmptyMessageDelayed(0, 1500);
     }
    
     private final StaticHandler mHandler = new StaticHandler(this);
    
     private static class StaticHandler extends Handler {
    
         protected WeakReference ref;
    
         public StaticHandler(T cls) {
             ref = new WeakReference(cls);
         }
    
         public T getRef() {
             return ref != null ? ref.get() : null;
         }
    
         @Override
         public void handleMessage(Message msg) {
             super.handleMessage(msg);
             MainActivity _Activity = (MainActivity) ref.get();
             _Activity.logMsg("StaticHandler 静态内部类log ");
         }
     }
    
  3. 在外部类生命周期结束前自主释放外部类的引用

你可能感兴趣的:(内存优化(二)如何避免内存泄漏)