最常见的8个Android内存泄漏问题及解决方法

作者：午后一小憩

在 Android 开发中，内存泄漏是一个常见的问题。这个问题可能会导致应用程序变慢、崩溃或者消耗大量的内存，最终导致设备性能下降。

什么是内存泄漏

内存泄漏指的是应用程序中存在一些对象或者资源无法被垃圾回收器回收，导致内存占用不断增加，最终导致设备性能下降。

内存泄漏的原因

对象未被正确回收

当对象的引用仍然存在时，但不再需要该对象时，没有及时释放对象会导致内存泄漏。

示例代码：

public void onCreate() {
    // ...
    MyObject object = new MyObject();
    // ...
}

// 解决方案：
public void onCreate() {
    // ...
    MyObject object = new MyObject();
    // 使用完object后，及时调用object = null，释放对象
    object = null;
    // ...
}

匿名类和内部类的引用

由于匿名类和内部类会隐式持有外部类的引用，如果不注意处理，可能导致外部类无法被正确回收。

示例代码：

public class MainActivity extends AppCompatActivity {
    public void onCreate() {
        // ...
        MyListener listener = new MyListener() {
            // ...
        };
        // ...
    }
}

// 解决方案：
public class MainActivity extends AppCompatActivity {
    private MyListener listener;

    public void onCreate() {
        // ...
        listener = new MyListener() {
            // ...
        };
        // ...
    }

    protected void onDestroy() {
        super.onDestroy();
        // 在合适的时机，及时将listener置空，释放外部类引用
        listener = null;
    }
}

单例模式导致的内存泄漏

如果使用单例模式的对象无法被释放或适时清理，会导致该对象一直存在于内存中。

示例代码：

public class MySingleton {
    private static MySingleton instance;

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

    // ...
}

// 解决方案：
public class MySingleton {
    private static MySingleton instance;

    public static MySingleton getInstance() {
        if (instance == null) {
            synchronized (MySingleton.class) {
                if (instance == null) {
                    instance = new MySingleton();
                }
            }
        }
        return instance;
    }

    public static void releaseInstance() {
        instance = null;
    }

    // ...
}

Handler 导致的内存泄漏

如果在使用Handler时，未正确处理消息队列和对外部类弱引用，可能导致外部类无法被回收。

示例代码：

public class MyActivity extends AppCompatActivity {
    private Handler handler = new Handler() {
        public void handleMessage(Message msg) {
            // ...
        }
    };

    // ...
}

// 解决方案：
public class MyActivity extends AppCompatActivity {
    private static class MyHandler extends Handler {
        private final WeakReference mActivity;

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

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

    private MyHandler handler = new MyHandler(this);

    // ...
}

长时间运行的后台任务

如果应用程序启动了一个后台任务，并且该任务的生命周期很长，这可能会导致内存泄漏。如在后台线程中执行网络请求或数据库操作，在任务完成后未正确处理对象的引用会导致内存泄漏。

示例代码：

public void startBackgroundTask() {
    new Thread(new Runnable() {
        public void run() {
            // 长时间运行的后台任务
        }
    }).start();
}

// 解决方案：
public void startBackgroundTask() {
    new Thread(new Runnable() {
        public void run() {
            // 长时间运行的后台任务
            // 任务执行完毕后，及时将相关对象引用置空
        }
    }).start();
}

Context 的错误引用

在Android开发中，Context引用是非常常见的内存泄漏原因。当将一个长生命周期的对象与Context关联时，如果未正确解除引用，将导致Context无法被回收。

示例代码：

public class MyActivity extends AppCompatActivity {
    public static MyActivity sInstance;

    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        sInstance = this;
    }
}

// 解决方案：
public class MyActivity extends AppCompatActivity {
    private static MyActivity sInstance;

    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        sInstance = this;
    }

    protected void onDestroy() {
        super.onDestroy();
        // 在关闭Activity时，及时解除引用
        sInstance = null;
    }
}

使用缓存导致的内存泄漏

使用缓存是为了提高性能和减少资源使用，但如果在缓存中保持过长时间的对象引用，有可能导致内存泄漏。

示例代码：

public class ObjectCache {
    private static final int MAX_SIZE = 100;
    private Map cache = new HashMap<>();

    public void put(String key, Object value) {
        cache.put(key, value);
        // 未添加移除操作
    }

    public Object get(String key) {
        return cache.get(key);
    }
}

// 解决方案：
public class ObjectCache {
    private static final int MAX_SIZE = 100;
    private Map> cache = new HashMap<>();

    public void put(String key, Object value) {
        if (cache.size() >= MAX_SIZE) {
            // 当缓存超过最大值时，尽可能移除一些旧的对象
            removeOldestObject();
        }
        cache.put(key, new WeakReference<>(value));
    }

    public Object get(String key) {
        WeakReference