Android 开发中常见的内存泄漏，如何避免和防范

内存泄漏（Memory Leak）在软件开发中指的是程序未能释放已不再需要的内存，从而导致内存的浪费。在Android应用开发中，内存泄漏尤其重要，因为移动设备通常内存较为有限，长期的内存泄漏会导致应用变慢、崩溃，甚至影响整个系统的稳定性。

• 内存泄漏的原因
  内存泄漏的原因多种多样，但在Android开发中，比较常见的原因包括：

1. 静态变量持有 Context引用：
   静态变量生命周期和应用生命周期一致，如果持有Activity或Context引用，会导致对应的Activity或Context无法被GC回收。

public class MySingleton {
    private static MySingleton instance;
    private Context context; // This holds a reference to a Context

    private MySingleton(Context context) {
        this.context = context.getApplicationContext();  // Use Application Context to avoid leak
    }

    public static MySingleton getInstance(Context context) {
        if (instance == null) {
            instance = new MySingleton(context);
        }
        return instance;
    }
}

2. 非静态内部类和匿名内部类：
   这些类会持有外部类的引用。比如，在Activity类中定义的内部类（如Handler、Runnable、AsyncTask等）会隐式持有Activity的引用。

public class MyActivity extends AppCompatActivity {
    private static class MyHandler extends Handler {
        private final WeakReference<MyActivity> mActivity;

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

        @Override
        public void handleMessage(Message msg) {
            MyActivity activity = mActivity.get();
            if (activity != null) {
                // Do something with activity
            }
        }
    }
}

3. 资源未正确关闭或释放：
   比如Bitmap、Cursor、File、Stream等资源没有正确关闭，会导致内存泄漏。

Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.id.my_image);
imageView.setImageBitmap(bitmap); // Make sure to recycle bitmap later
// ... Later in code
bitmap.recycle();

4. 监听器、回调未及时注销：
   注册在系统或框架中的监听器，长时间持有Activity或View的引用。

@Override
protected void onPause() {
    super.onPause();
    locationManager.removeUpdates(locationListener); // Unregister listener
}

• 如何避免和防范内存泄漏

1. 使用Application Context：
   当需要长时间使用Context时，尽量使用Application Context而非Activity Context。

Context appContext = getApplicationContext();

2. 使用静态内部类来避免隐式引用外部类：
   避免非静态内部类和匿名内部类，改用静态内部类，必要时使用弱引用（WeakReference）。

private static class MyTask extends AsyncTask<Void, Void, Void> {
    private final WeakReference<MyActivity> activityReference;

    MyTask(MyActivity context) {
        activityReference = new WeakReference<>(context);
    }

    @Override
    protected Void doInBackground(Void... voids) {
        // Do background task
        return null;
    }

    @Override
    protected void onPostExecute(Void result) {
        MyActivity activity = activityReference.get();
        if (activity == null || activity.isFinishing()) return;
        // Update UI
    }
}

AsyncTask现在用的少了，类似的还有Handler，以及一些耗时任务，需要注意Context引用问题。

3. 及时释放资源：
   在Activity的生命周期方法中正确释放资源，特别是在onDestroy()中。

@Override
protected void onDestroy() {
    super.onDestroy();
    if (bitmap != null) {
        bitmap.recycle();
        bitmap = null;
    }
}

4. 弱引用和Soft引用：
   当持有大型对象的引用时，可以使用弱引用（WeakReference）和软引用（SoftReference）。

 WeakReference<Context> weakReference = new WeakReference<>(context);

5. 使用开发工具检查内存泄漏：
   利用Android Studio自带的内存分析工具、LeakCanary等第三方工具检测运行时的内存泄漏。

dependencies {
    debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.7'
}

• 定期对应用进行内存使用情况的检查和优化，提前识别并解决潜在的内存泄漏问题。
• 在多线程操作中，小心处理线程生命周期，确保在线程结束后释放资源。
• 遵循最佳实践和代码规范，如尽量少使用Singleton模式持有Context引用，避免全局- 静态变量持有Activity或View。
• 谨慎处理匿名回调和观察者模式，确保在对象销毁前移除绑定。
• 通过上述方法和示例，可以有效地避免和防范Android应用开发中的内存泄漏，提应用的稳定性和用户体验。