Android内存泄漏原因及解决的总结

分三步说明Android内存泄漏的原因及解决，“内存泄漏与内存溢出的区别”，“引用方式”，“常见引发原因与解决方案”

内存泄漏与内存溢出

内存溢出 out of memory，是指你的应用的内存已经不能满足正常使用了，堆栈已经达到系统设置的最大值，进而导致崩溃，这是一种结果描述

内存泄露 memory leak，是指程序在申请内存后，对于使用后的资源没有及时释放，而这一资源在一段时间内也无法被自动回收，这是一种状态描述。内存泄露堆积后果很严重，无论多少内存,迟早会被占光。

memory leak的堆积导致out of memory

引用

1. 强引用（StrongReference）：只要引用存在，垃圾回收器永远不会回收。
   Object obj = new Object();
   这个obj对象对后面new Object的一个强引用，只有当obj不再引用，对象才会被回收，内存被释放

2. 软引用（SoftReference）：如果一个对象具有软引用，当内存空间不足，GC会回收这些对象的内存。
   可以和一个引用队列（ReferenceQueue）联合使用

Object obj = new Object();
SoftReference<Object> sf = new SoftReference<Object>(obj);
obj = null;
sf.get();

内存不足将反null，如未被回收Object obj = (Object)sf.get();

//与ReferenceQueue 联合使用
ReferenceQueue queue = new  ReferenceQueue();
SoftReference  ref=new  SoftReference(Object, queue);

当软引用被回收，ref也将被加入ReferenceQueue 队列，通过队列可以清除无用ref

3. 弱引用（WeakReference）：具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存
   可以和一个引用队列（ReferenceQueue）联合使用

Object obj = new Object();
WeakReference<Object> wf = new WeakReference<Object>(obj);
obj = null;
wf.get();
wf.isEnQueued();//返回是否被垃圾回收器标记为即将回收的垃圾

4. 虚引用（PhantomReference）：虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。
   虚引用必须和引用队列 （ReferenceQueue）联合使用

内存泄露

Android的内存泄漏主要源于强引用导致的资源无法回收，其中引用Activity的context最麻烦，它包含大量的内存引用，例如View Hierarchies和其他资源。对于内存泄漏与其对应的解决如下：

匿名内部类（匿名类也持有着外部类的强引用）

java中可以直接new一个接口，然后在new加入实现代码，简化的代码，只要不跨越生命周期，内部类是完全没问题的。但是，下面这些类是用于产生后台线程的，这些Java线程是全局的，而且持有创建者的引用（即匿名类的引用），而匿名类又持有外部类的引用。线程不结束，Activity无法回收。所以只能写成静态的内部类。
（关于handler：如果想要在handler内部去调用所在的外部类Activity，那么可以在handler内部使用弱引用的方式指向所在Activity，这样统一不会导致内存泄漏。）

1. AsyncTsk

void startAsyncTask() {
    new AsyncTask<Void, Void, Void>() {
        @Override protected Void doInBackground(Void... params) {
            while(true);
        }
    }.execute();
}
//解决
private static class NimbleTask extends AsyncTask<Void, Void, Void> {
    @Override protected Void doInBackground(Void... params) {
        while(true);
    }
}
void startAsyncTask() {
    new NimbleTask().execute();
}

2. Handler

       void createHandler() {
        new Handler() {
        @Override public void handleMessage(Message message) {
            super.handleMessage(message);
        }
       }.postDelayed(new Runnable() {
        @Override public void run() {
            while(true);
        }
       }, Long.MAX_VALUE >> 1);
       }
       //解决
       private static class NimbleHandler extends Handler {
        private final WeakReference<SampleActivity> mActivity;

        public NimbleHandler (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);
       private static class NimbleRunnable implements Runnable {
        @Override public void run() {
        while(true);
        }
       }

    void createHandler() {
    new NimbleHandler().postDelayed(new NimbleRunnable(), Long.MAX_VALUE >> 1);
}//或者使用WeakHandler

3. Thread、TimerTask

       void scheduleTimer() {
        new Timer().schedule(new TimerTask() {
        @Override
        public void run() {
            while(true);
        }
       }, Long.MAX_VALUE >> 1);
       }
       //解决
       private static class NimbleTimerTask extends TimerTask {
        @Override public void run() {
        while(true);
        }
       }

       void scheduleTimer() {
        new Timer().schedule(new NimbleTimerTask(), Long.MAX_VALUE >> 1);
      }

static的Activity，view

这种泄漏是因为Activity和view等被静态的变量引用，因为静态变量的生命周期长于Activity，强引用导致Activity或view无法释放资源。用弱引用解决。view的强引用可以在onDestroy中置null

private static WeakReference<MainActivity> activityReference;
    void setStaticActivity() {
        activityReference = new WeakReference<MainActivity>(this);
    }

单例中传入context

单例生命周期与Application一样长，当传入Activity的context导致单例长期持有Activity无法销毁，内存泄漏。将构造方法中的context = context.getApplicationContext()，这样将不影响Activity的销毁

静态的变量引用非静态内部类

静态变量 持有 非静态内部类 持有 Activity。间接的Activty被长生命周期持有，导致无法销毁。可以在Activity生命周期中置null，或者改非静态内部类为静态等办法。

一些占内存的资源（图片类，较大文件等）使用过后及时清空