Android 常见的内存泄露-CSDN博客

本文链接：https://blog.csdn.net/JohanMan/article/details/76998470

当一个对象不再需要时，本应该被回收，而被另一个正在使用的对象（可能是静态对象，也有可能是匿名内部类对象，等等）引用导致不能正常被回收，就会一直存活在堆中，造成内存泄露。内存泄露会使程序造成程序OOM（Out Of Memory），导致应用Crash。

单例造成的内存泄漏

由于单例的静态特性，使得单例对象和应用的生命周期一样长。所以被单例对象引用的对象，如果不主动置为null释放对象，那么被引用的对象便和单例对象“共生死”，即使被引用的对象不需要了，也不能被回收，从而造成内存泄露。
如例子：

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;
    }
}

这样写本来没错，如果你这么用的话：

public class MainActivity extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        AppManger appManager = AppManager.getInstance(this);
    }
}

那MainActivity就别想被回收了，给我老实待在堆内存中吧！！原因是被单例AppManager所引用。改善的方法：

public class MainActivity extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        AppManger appManager = AppManager.getInstance(getApplicationContext());
    }
}

这样使用的话，MainActivity就不会被引用，如果没有其他地方引用MainActivity的话，等finish了，就可以等着被回收了。

非静态内部类造成的内存泄露

非静态内部类（包括匿名内部类）会持有外部类对象的强引用（如 Activity），所以很容易导致内存泄露，比如 Handler, Runnable 。

Handler内存泄露

public class MainActivity extends AppCompatActivity {
    private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            // TODO Something
        }
    };
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        loadData();
        finish();
    }
    private void loadData() {
        Message message = Message.obtain();
        mHandler.sendMessageDelayed(message, 100000);
    }
}

因为mHandler是MainActivity的内部类，所以隐式持有MainActivity这个实例。由于Handler还有没有处理的Message，而Message持有mHandler实例，此时即使MainActivity关掉了，内存资源也无法及时被回收，造成内存泄露。解决办法：

public class MainActivity extends AppCompatActivity {
    private MyHandler mHandler = new MyHandler(this);
    private TextView mTextView ;
    private static class MyHandler extends Handler {
        private WeakReference<Context> reference;
        public MyHandler(Context context) {
            reference = new WeakReference<>(context);
        }
        @Override
        public void handleMessage(Message msg) {
            MainActivity activity = (MainActivity) reference.get();
            if(activity != null){
                activity.mTextView.setText("");
            }
        }
    }
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mTextView = (TextView)findViewById(R.id.textview);
        loadData();
        finish();
    }
    private void loadData() {
        //...request
        Message message = Message.obtain();
        mHandler.sendMessageDelayed(message, 100000);
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        mHandler.removeCallbacksAndMessages(null);
    }
}

把非静态内部类声明为静态内部类（其实就相当于单独的一个类，写在某个类里面而已），这样的话mHandler就不再直接持有MainActivity实例了。
因为要用到MainActivity实例，使用弱引用方式引用MainActivity实例，这样即使mHandler还有没处理的Message，等MainActivity关掉了，MainActivity资源也可以正常被回收。
虽然步骤1和2避免了Activity泄漏，不过Looper线程的消息队列中还是可能会有待处理的消息，所以我们在Activity的Destroy时或者Stop时应该调用mHandler的removeCallbacksAndMessages或者removeCallbacks移除消息队列中的消息。

Runnable内存泄露

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        new Thread(new Runnable() {
            @Override
            public void run() {
                SystemClock.sleep(10000);
            }
        }).start();
        finish();
    }
}