性能优化—防止内存泄漏和溢出

如何找到项目中存在的内存泄露的这些地方呢？

1.确定是否存在内存泄露

• Android Monitors的内存分析

最直观的看内存增长情况，知道该动作是否发生内存泄露。动作发生之前： GC完后内存1.4M; 动作发生之后：GC完后内存1.6M

• 使用MAT内存分析工具

MAT分析heap的总内存占用大小来初步判断是否存在泄露Heap视图中有一个Type叫做data object，即数据对象，也就是我们的程序中大量存在的类类型的对象。在data object一行中有一列是“Total Size”，其值就是当前进程中所有Java数据对象的内存总量，一般情况下，这个值的大小决定了是否会有内存泄漏。我们反复执行某一个操作并同时执行GC排除可以回收掉的内存，注意观察data object的Total Size值，正常情况下Total Size值都会稳定在一个有限的范围内，也就是说由于程序中的的代码良好，没有造成对象不被垃圾回收的情况。
反之如果代码中存在没有释放对象引用的情况，随着操作次数的增多Total Size的值会越来越大。那么这里就已经初步判断这个操作导致了内存泄露的情况。

2.先找怀疑对象(哪些对象属于泄露的)

MAT对比操作前后的hprof来定位内存泄露是泄露了什么数据对象。（这样做可以排除一些对象，不用后面去查看所有被引用的对象是否是嫌疑）快速定位到操作前后所持有的对象哪些是增加了(GC后还是比之前多出来的对象就可能是泄露对象嫌疑犯)。
技巧：Histogram中还可以对对象进行Group，比如选择Group By Package更方便查看自己Package中的对象信息。

3. MAT分析hprof来定位内存泄露的原因所在。

(哪个对象持有了上面怀疑出来的发生泄露的对象)

• 1 Dump出内存泄露“当时”的内存镜像hprof，分析怀疑泄露的类；

• 2 把上面2得出的这些嫌疑犯一个一个排查个遍。步骤：
  2.1 进入Histogram，过滤出某一个嫌疑对象类
  2.2 然后分析持有此类对象引用的外部对象（在该类上面点击右键List Objects--->with incoming references）
  2.3 再过滤掉一些弱引用、软引用、虚引用，因为它们迟早可以被GC干掉不属于内存泄露 (在类上面点击右键Merge Shortest Paths to GC Roots--->exclude all phantom/weak/soft etc.references)
  2.4 逐个分析每个对象的GC路径是否正常此时就要进入代码分析此时这个对象的引用持有是否合理，这就要考经验和体力了！（比如上课的例子中：旋转屏幕后MainActivity有两个，肯定MainActivity发生泄露了.

那谁导致他泄露的呢？

原来是我们的CommonUtils类持有了旋转之前的那个MainActivity他，那是否合理？结合逻辑判断当然不合理，由此找到内存泄露根源是CommonUtils类持有了该MainActivity实例造成的。

怎么解决？

罪魁祸首找到了，怎么解决应该不难了，不同情况解决办法不一样，要靠你的智慧了。）context.getapplictioncontext()可以吗？
可以！！只要让CommonUtils类不直接只有MainActivity的实例就可以了。

---

4 判断一个应用里面内存泄露避免得很好，怎么看？

当app退出的时候，这个进程里面所有的对象应该就都被回收了，尤其是很容易被泄露的（View，Activity）是否还内存当中。
可以让app退出以后，查看系统该进程里面的所有的View、Activity对象是否为0.
工具：使用AndroidStudio--AndroidMonitor--System Information--Memory Usage查看Objects里面的views和Activity的数量是否为0.
命令行模式：

5 内存泄露经常出现的例子

• 内存泄露(Memory Leak)
  进程中某些对象已经没有使用价值了，但是他们却还可以直接或者间接地被引用到GC Root导致无法回收。当内存泄露过多的时候，再加上应用本身占用的内存，日积月累最终就会导致内存溢出OOM.

• 内存溢出(OOM)
  当应用占用的heap资源超过了Dalvik虚拟机分配的内存就会内存溢出。比如：加载大图片。

• • 5.1 静态变量引起的内存泄露
    当调用getInstance时，如果传入的context是Activity的context。只要这个单
    利没有被释放，那么这个Activity也不会被释放一直到进程退出才会释放。

    public class CommUtil {
    private static CommUtil instance;
    private Context context;
    private CommUtil(Context context){
    this.context = context;
    }
      public static CommUtil getInstance(Context mcontext){
    if(instance == null){
          instance = new CommUtil(mcontext);
    }
        //        else{
        //            instance.setContext(mcontext);
        //        }
    return instance;
          }
    

• • 5.2.非静态内部类引起内存泄露
    (包括匿名内部类)错误的示范：

    public void loadData(){//隐式持有MainActivity实例。MainActivity.this.a
    new Thread(new Runnable() {
        @Override
        public void run() {
        while(true){
            try {
            //int b=a;
            Thread.sleep(1000);
            } catch (InterruptedException e) {
            e.printStackTrace();
            }
        }
        }
    }).start();
    }
    

    解决方案

    将非静态内部类修改为静态内部类。（静态内部类不会隐士持有外部类）

当使用软引用或者弱引用的时候，MainActivity难道很容易或者可以被GC回收吗？GC回收的机制是什么？
当MainActivity不被任何的对象引用，才会被回收。虽然Handler里面用的是软引用/弱引用，但是并不意味着不存在其他的对象引用该MainActivity。我连MainActivity都被回收了，那他里面的Handler还玩个屁。

• • 5.3.不需要用的监听未移除会发生内存泄露
    // tv.setOnClickListener();//监听执行完回收对象
    //add监听，放到集合里面
    tv.getViewTreeObserver().addOnWindowFocusChangeListener
    (new ViewTreeObserver.OnWindowFocusChangeListener() {
    @Override
    public void onWindowFocusChanged(boolean b) {
    //监听view的加载，view加载出来的时候，计算他的宽高等。

           //计算完后，一定要移除这个监听
           tv.getViewTreeObserver().removeOnWindowFocusChangeListener(this);
       }
         });
    
     例子2：
     SensorManager sensorManager = getSystemService(SENSOR_SERVICE);
     Sensor sensor =   sensorManager.getDefaultSensor(Sensor.TYPE_ALL);
     sensorManager.registerListener(this,sensor,SensorManager.SENSOR_DELAY_FASTEST);
     //不需要用的时候记得移除监听
     sensorManager.unregisterListener(listener);
    

• • 5.4.资源未关闭引起的内存泄露情况

  比如：BroadCastReceiver、Cursor、Bitmap、IO流、自定义属性attribute attr.recycle()回收。
  当不需要使用的时候，要记得及时释放资源。否则就会内存泄露。

• • 5.5.无限循环动画

没有在onDestroy中停止动画，否则Activity就会变成泄露对象。
比如：轮播图效果。

6 常用代码片段

6.1 Handler防止内存泄漏
如果Handler在Activity退出的时候，有可能还活着，这时候就会一直持有Activity。

private static class MyHandler extends Handler{
    // private MainActivity mainActivity;//直接持有了一个外部类的强引用，会内存泄露
    //设置软引用保存，当内存一发生GC的时候就会回收。
    private WeakReference<MainActivity> mainActivity;

    public MyHandler(MainActivity mainActivity) {
        this.mainActivity = new WeakReference<MainActivity>(mainActivity);
    }

    @Override
    public void handleMessage(Message msg) {
        super.handleMessage(msg);
        MainActivity main =  mainActivity.get();
        if(main==null||main.isFinishing()){
            return;
        }
        switch (msg.what){
            case 0:
                //加载数据
        //MainActivity.this.a;//有时候确实会有这样的需求：需要引用外部类的资源。怎么办？
                int b = main.a;
                break;
        }
    }
};

6.2 弱引用的使用
当垃圾回收时就会释放那些没有被引用的内存。
如下面，当key值View没有被引用时，那么map集合就会丢弃次值。

public class ListenerCollector {
    /**
     * WeakHashMap，此种Map的特点是，当除了自身有对key的引用外，此key没有其他引用那么此map
     * 会自动丢弃此值
     * 例如：int a = 1;
     * Map weakmap = new WeakHashMap();
     * weakmap.put(a, "aaa");z  x
     * a = null
     * //此时weakmap里面的a会被丢弃。
     */
    static private WeakHashMap<View, MyView.MyListener> sListener = new WeakHashMap<>();

    public void setsListener(View view, MyView.MyListener listener) {
        sListener.put(view, listener);
    }

    public static void clearListeners() {
        //移除所有监听。
        sListener.clear();
    }
}

6.3 使匿名内部类变成静态匿名内部类
静态匿名内部类不属于外部类，不持有外部类的引用。下面的线程有可能在activity已经被finish了，还没有执行结束，因此需要将其改成static。

//加上static，里面的匿名内部类就变成了静态匿名内部类
//隐士持有MainActivity实例。MainActivity.this.a
public static void loadData(){
    new Thread(new Runnable() {
        @Override
        public void run() {
            while(true){
                try {
                    int b=a;
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }).start();
}