Android内存泄漏示例

“内存泄漏”就是一个对象已经不需要再使用了，但是因为其它的对象持有该对象的引用，导致它的内存不能被回收。“内存泄漏”的慢慢积累，最终会导致OOM的发生，导致程序崩溃闪退。本篇将总结典型的内存泄漏的代码，并给出对应的解决方案。
一、内存泄漏的类型：

1. 静态变量引起的内存泄漏
2. 非静态内部类引起的内存泄漏
3. 资源未关闭引起的内存泄漏

二、静态变量引起的内存泄漏

1. 示例
   单例模式引起的Context内存泄漏

public static FileServiceManager getInstance(Context context) {
    if(mInstance== null) {
        mInstance = new FileServiceManager(context);
    }

    return mInstance;
}

这是一个典型的单例，在调用getInstance()的时候，如果Context传入的是Activity的Context，只要这个单例没有被释放（mInstance是一个静态变量），那么Activity也不会被释放。

2.解决方案：
传入的Context应为Application的Context，Application的生命周期贯穿整个应用，所以用Application的Context最合适不过了。

三、非静态内部类引起的内存泄漏

在java中，创建一个非静态匿名内部类实例，就会引用其外围实例，如果这个非静态匿名内部类实例做一些耗时操作，在耗时操作的时候关闭了外围实例，那么这个时候外围对象并不会被回收，从而造成了内存泄漏。
1. 示例

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    getNetData();
}

private void getNetData() {
    new Thread(){
        @Override
        public void run() {
            super.run();
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }.start();
}

创建非静态匿名内部类Thread，该Thread将引用外围的Activity，在10000毫秒内关闭该Activity的话，此时Activity是不会被回收的。

解决方案：
1. 将匿名内部类变为静态内部类
2. 在Activity要destory的时候，将所有的耗时操作结束了
3. 如果有强引用Activity中的属性，则将该属性的引用方式改为弱引用

private static void getNetData() {
    new Thread(){
        @Override
        public void run() {
            super.run();
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    };
}

再看一个例子：
handler引起的内存泄漏

public class TabHomeActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        getNetData();
    }

    private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);

            switch (msg.what) {
                case 1:
                    break;
                default:
                    break;
            }
        }
    };

mHandler为内部类，会引用外部实例TabHomeActivity.this，如果在该Activity结束时mHandler的MessageQueue中仍然还有消息未处理，则该Activity不会被回收。

解决方案

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    handler = new MyHandler(this);
}

// 1.内部类变为静态内部类
private static class MyHandler extends Handler {
    // 2.引用到外部实例的地方，改成弱引用
    private WeakReference<Activity> mActivity;

    private MyHandler(Activity activity) {
        mActivity = new WeakReference<Activity>(activity);
    }

    @Override
    public void handleMessage(Message msg) {
        super.handleMessage(msg);
        // 如果Activity被释放了，则部处理信息了
        Activity activity = mActivity == null ? null : mActivity.get();
        if (activity == null || activity.isFinishing())
            return;

        // TODO UI操作、、、、、。。。
    }
}

private Handler handler;

@Override  protected void onDestroy() {
    //第三步，在Activity退出的时候移除回调
    super.onDestroy();
    handler.removeCallbacksAndMessages(null);
}

四、资源未关闭引起的内存泄漏

当使用了BraodcastReceiver、Cursor、Bitmap等资源时，当不需要使用时，需要及时释放掉，若没有释放，则会引起内存泄漏。综上所述，就是资源在不需要的时候没有被释放掉。所以在编码的过程中要注意这些细节，提高程序的性能。