盒子
盒子
文章目录
  1. 什么是内存泄漏
  2. 内存泄漏的原因
    1. 对象未被正确回收
    2. 匿名类和内部类的引用
    3. 单例模式导致的内存泄漏
    4. Handler 导致的内存泄漏
    5. 长时间运行的后台任务
    6. Context 的错误引用
    7. 使用缓存导致的内存泄漏
    8. 未关闭的资源
  3. 如何检测内存泄漏
  4. 如何避免内存泄漏
  5. 结论
  6. 推荐

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

2023.07.05 Rouse android  热度 ℃

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

什么是内存泄漏

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

内存泄漏的原因

对象未被正确回收

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

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public void onCreate() {
    // ...
    MyObject object = new MyObject();
    // ...
}

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

匿名类和内部类的引用

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

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
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;
    }
}

单例模式导致的内存泄漏

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

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
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时，未正确处理消息队列和对外部类弱引用，可能导致外部类无法被回收。

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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<MyActivity> 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);

    // ...
}

长时间运行的后台任务

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

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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无法被回收。

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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;
    }
}

使用缓存导致的内存泄漏

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

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public class ObjectCache {
    private static final int MAX_SIZE = 100;
    private Map<String, Object> 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<String, WeakReference<Object>> 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<Object> weakRef = cache.get(key);
        if (weakRef != null) {
            return weakRef.get();
        }
        return null;
    }

    private void removeOldestObject() {
        // 移除一些旧的对象
    }
}

未关闭的资源

在使用一些资源，如数据库连接、文件输入/输出流等时，如果在使用完毕后未显式关闭这些资源，会导致资源泄漏和内存泄漏。

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public void readFromFile() {
    FileInputStream inputStream = null;
    try {
        inputStream = new FileInputStream("file.txt");
        // 读取数据
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        // 未及时关闭资源
    }
}

// 解决方案：
public void readFromFile() {
    FileInputStream inputStream = null;
    try {
        inputStream = new FileInputStream("file.txt");
        // 读取数据
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (inputStream != null) {
            try {
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

如何检测内存泄漏

Android Studio 提供了一些工具，可以帮助开发者检测内存泄漏问题。例如：

  1. Memory Profiler：可用于分析应用程序的内存使用情况，并查看对象的实例数、生命周期和内存泄漏情况。
  2. Allocation Tracker：可用于跟踪对象的创建和释放，帮助开发者识别内存泄漏问题。
  3. LeakCanary：一个开源库，专门用于检测和记录内存泄漏情况，并提供详细的堆转储（heap dump）和内存泄漏分析。

如何避免内存泄漏

以下是一些常见的内存泄漏避免方法：

  1. 及时释放对象：在不再需要对象时，及时将其引用置空，以便垃圾回收器能够正确回收对象。
  2. 使用弱引用：对于可能导致内存泄漏的对象引用，使用弱引用来避免强引用导致的无法回收问题。
  3. 避免使用静态对象：静态对象生命周期长，容易导致内存泄漏，尽量避免过度使用静态对象。
  4. 避免使用匿名类和内部类：匿名类和内部类隐式地持有外部类的引用，容易导致外部类无法被回收。
  5. 避免使用单例模式：如果单例模式对象无法适时释放，会一直存在于内存中，增加内存占用。
  6. 避免 Handler 导致的内存泄漏：使用静态内部类和对外部类的弱引用来避免Handler导致的内存泄漏。

结论

内存泄漏是一个常见的问题，在 Android 开发中需要注意。开发者需要了解内存泄漏的原因，以及如何检测和避免内存泄漏问题。通过及时释放对象、使用弱引用、避免使用静态对象、匿名类和内部类，以及正确处理Handler，开发者可以有效地避免内存泄漏问题，从而提高应用程序的稳定性和性能。

另外，Android Studio提供的内存分析工具如Memory Profiler、Allocation Tracker和LeakCanary可以帮助开发者检测和解决内存泄漏问题，建议开发者加以利用。

推荐

android_startup: 提供一种在应用启动时能够更加简单、高效的方式来初始化组件，优化启动速度。不仅支持Jetpack App Startup的全部功能，还提供额外的同步与异步等待、线程控制与多进程支持等功能。

AwesomeGithub: 基于Github的客户端，纯练习项目，支持组件化开发，支持账户密码与认证登陆。使用Kotlin语言进行开发，项目架构是基于JetPack\&DataBinding的MVVM；项目中使用了Arouter、Retrofit、Coroutine、Glide、Dagger与Hilt等流行开源技术。

flutter_github: 基于Flutter的跨平台版本Github客户端，与AwesomeGithub相对应。

android-api-analysis: 结合详细的Demo来全面解析Android相关的知识点, 帮助读者能够更快的掌握与理解所阐述的要点。

daily_algorithm: 每日一算法，由浅入深，欢迎加入一起共勉。

支持一下
赞赏是一门艺术