移动开发最新探索 Android 内存优化方法，阿里面试题目及答案

最后

其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。

下面分享的腾讯、头条、阿里、美团、字节跳动等公司2019-2021年的高频面试题全套解析，博主还把这些技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，下面只是以图片的形式给大家展示一部分。

知识不体系？这里还有整理出来的Android进阶学习的思维脑图，给大家参考一个方向。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

如果服务器返回给我们的图片是 200 * 200，但是我们的 ImageView 大小是 100 * 100，如果直接把图片加载到 ImageView 中，那就是一种内存浪费。

但是使用的 Glide 的话，那这个问题就不用担心了，因为 Glide 会根据 ImageView 的大小把图片大小调整成 ImageView 的大小加载图片，并且 Glide 有三级缓存，在内存缓存中，Glide 会根据屏幕大小选择合适的大小作为图片内存缓存区的大小。

7. 内存泄漏与内存抖动

常见的内存问题有内存泄漏和内存抖动两种，下面来看下内存泄漏是什么。

内存泄漏指的是一块内存没有被使用且无法被 GC 回收，从而造成了内存的浪费，比如 Handler 匿名内部类持有 Activity 的引用，Activity 需要销毁时，GC 就无法回收它。

内存泄漏的表现就是可用内存逐渐减少，比如下图中是一种比较严重的内存泄漏现象，无法被回收的内存逐渐累积，直到应用无更多可用内存可申请时，就会导致 OOM。

常见的导致内存泄漏的 3 个原因分别是：非静态内部类、静态变量、资源未释放，内存泄漏的本质就是长生命周期对象持有了短生命周期对象的引用`，导致短生命周期对象无法被释放。

7.1 非静态内部类

1. 原因

非静态内部类会持有外部类的实例，比如匿名内部类就是非静态内部类，匿名内部类指的是一个没有人类可识别名称的类，但是在字节码中，匿名内部类也有构造函数，而这个构造函数的参数就包含外部类的实例。

比如在 Activity 中以匿名内部类的方式声明 Handler 或 AsyncTask，当 Activity 关闭时，由于 Handler 持有 Activity 的强引用，导致 GC 无法对 Activity 进行回收。

当我们通过 Handler 发送消息时，消息会加入到 MessageQueue 队列中交给 Looper 处理，当有消息还没发送完毕时，Looper 会一直运行，在这个过程中会一直持有 Handler，而 Handler 又持有外部类 Activity 的实例，这就导致了 Activity 无法被释放。

2. 解决方案

我们可以把 Handler 或 AsyncTask 声明为静态内部类，并且使用 WeakReference 包住 Activity，这样 Handler 拿到的就是一个 Activity 的弱引用，GC 就可以回收 Activity。

这种方式适用于所有匿名内部类导致的内存泄漏问题。

public static class MyHandler extends Handler {
Activity activity;

public MyHandler(Activity activity) {
activity = new WeakReference<>(activity).get();
}

@Override
public void handleMessage(Message message) {
// …
}

}

7.2 静态变量

1. 原因

静态变量导致内存泄漏的原因是因为长生命周期对象持有了短生命周期对象的引用，导致短生命周期对象无法被释放。

比如一个单例持有了 Activity 的引用，而 Activity 的生命周期可能很短，用户一打开就关闭了，但是单例的生命周期往往是与应用的生命周期相同的，从而导致 Activity 无法被释放。

2. 解决方案

如果单例需要 Context， 可以考虑使用 ApplicationContext，这样单例持有的 Context 引用就是与应用的生命周期相同的了。

7.3 资源未释放

1. 忘了注销 BroadcastReceiver

2. 忘了关闭数据库游标（Cursor）

3. 忘了关闭流

4. 忘了调用 recycle() 方法回收创建的 Bitmap 使用的内存

5. 忘了在 Activity 退出时取消 RxJava 或协程所开启异步任务

6. Webview

不同的 Android 版本的 Webview 会有差异，加上不同厂商定制 ROM 的 Webview 的差异，导致 Webview 存在很大的兼容问题，一般情况下，在应用中只要使用一次 Webview，它占用的内存就不会被释放，解决方案：WebView内存泄漏–解决方法小结 。

​

7.4 内存抖动

当我们在短时间内频繁创建大量临时对象时，就会引起内存抖动，比如在一个 for 循环中创建临时对象实例，下面这张图就是内存抖动时的一个内存图表现，它的形状是锯齿形的，而中间的垃圾桶代表着一次 GC。

这个是 Memory Profiler 提供的内存实时图，后面会对 Memory Profiler 进行一个更详细的介绍。

• 尽量避免在循环体中创建对象
• 尽量不要在自定义 View 的 onDraw() 方法中创建对象，因为这个方法会被频繁调用
• 对于能够复用的对象，可以考虑使用对象池把它们缓存起来

8. 什么是 Memory Profiler？

1. Memory Profiler 简介

常用的分析 Android 应用内存使用情况的工具有 3 种：Memory Profiler、MAT 和 LeakCanary，下面先来看下 Memory Profiler 。

Memory Profiler 是 Profiler 中的其中一个版块，Profiler 是 Android Studio 为我们提供的性能分析工具，使用 Profiler 能分析应用的 CPU、内存、网络以及电量的使用情况。

打开 Profiler 有下面三种方式。

1. View > Tool Windows > Android Profiler
2. 下方的 Profiler 标签
3. 双击 shift 搜索 profiler

打开 Profiler 后，可以看到下面这样的面板，而在左边的 SESSIONS 面板的右上角，有一个加号，在这里可以选择我们想要进行分析的应用。

开了高级选项后，我们在 Memory Profiler 中就能看到用一个白色垃圾桶表示的 GC 动作。

打开 Profiler 的方式：Run > Edit Configucation > Profiling > Enable advanced profiling

而 Memory Profiler 是 Profiler 的其中一个功能，点击 Profiler 中蓝色的 Memory 面板，我们就进入了 Memory Profiler 界面。

2. 堆转储

在堆转储（Dump Java Heap）面板中有 Instance View（实例视图）面板，Instance View 面板的下方有 References 和 Bitmap Preview 两个面板，通过 Bitmap Preview，我们能查看该 Bitmap 对应的图片是哪一张，通过这种方式，很容易就能找到图片导致的内存问题。

要注意的是，Bitmap Preview 功能只有在 7.1 及以下版本的设备中才能使用。

3. 查看内存分配详情

在 7.1 及以下版本的设备中，可以通过 Record 按钮记录一段时间内的内存分配情况。

而在 8.0 及以上版本的设别中，可以通过拖动时间线来查看一段时间内的内存分配情况。

点击 Record 按钮后，Profiler 会为我们记录一段时间内的内存分配情况。在内存分配面板中，我们可以查看对象的分配的位置，比如下面的 Bitmap 就是在 onCreate 方法的 22 行创建的。

9. Memory Analyzer Tool

对于内存泄漏问题，Memory Profiler 只能给我们提供一个简单的分析，不能够帮我们确认具体发生问题的地方。

而 MAT 就可以帮我们做到这一点，MAT 的全称是 Memory Analyzer Tool，它是一款功能强大的 Java 堆内存分析工具，可以用于查找内存泄漏以及查看内存消耗情况。

1. MAT 使用步骤

要想通过 MAT 分析内存泄漏，我们做下面几件事情。

1. 到 MAT 的官网下载 MAT。

2. 使用 Memory Profiler 的堆转储功能，导出 hprof（Heap Profile）文件。

3. 配置 platform-tools 环境变量

4. 使用命令将 Memory Profiler 中导出来的 hprof 文件转换为 MAT 可以解析的 hprof 文件，命令如下

platform-tools hprof-conv …/原始文件.hprof …/输出文件.hprof

5. 打开 MAT

6. File > open Heap dump ，选择我们转换后的文件

2. 注意事项

1. 如果在 mac 上打不开 MAT，可以参考Eclipse Memory Analyzer在Mac启动报错

2. 如果在 mac 上配置 platform-tools 不成功的话，可以直接定位到 Android SDK 下的 platform-tools 目录，直接使用 hprof-conv 工具，命令如下

hprof-conv -z …/原始文件.hprof …/输出文件.hprof

3. 分析内存泄漏

我在项目中定义了一个静态的回调列表 sCallbacks，并且把 MemoryLeakActivity 添加到了这个列表中，然后反复进出这个 Activity，我们可以看到这个 Activity 的实例有 8 个，这就属于内存泄漏现象，下面我们来看下怎么找出这个内存泄漏。

首先，按 9.2 小节的步骤打开我们的堆转储文件，打开后，我们可以看到 MAT 为我们分析的一个预览页。

打开左上角的直方图，我们可以看到一个类列表，输入我们想搜索的类，就可以看到它的实例数。

我们右键 MemoryLeakActivity 类，选择 List Objects > with incoming references 查看这个 Activity 的实例。

点击后，我们能看到一个实例列表，再右键其中一个实例，选择 Path to GC Roots > with all references 查看该实例被谁引用了，导致无法回收。

选择 with all references 后，我们可以看到该实例被静态对象 sCallbacks 持有，导致无法被释放。

这样就完成了一次简单的内存泄漏的分析。

10. LeakCanary

如果使用 MAT 来分析内存问题，会有一些难度，而且效率也不是很高，为了能迅速发现内存泄漏，Square 公司基于 MAT 开源了 LeakCanary，LeakCanary 是一个内存泄漏检测框架。

10.1 LeakCanary 原理

##### 1. 检测保留的实例

LeakCanary 是基于 LeakSentry 开发的，LeakSentry 会 hook Android 生命周期，自动检测当 Activity 或 Fragment 被销毁时，它们的实例是否被回收了。

销毁的实例会传给 RefWatcher，RefWatcher 会持有它们的弱引用。

你也可以观察所有不再需要的实例，比如一个不再使用的 View，不再使用的 Presenter 等。

如果等待了 5 秒，并且 GC 触发了之后，弱引用还没有被清理，那么 RefWatcher 观察的实例就可能处于内存泄漏状态了。

##### 2. 堆转储

当保留实例（Retained Instance）的数量达到了一个阈值，LeakCanary 会进行堆转储，并把数据放进 hprof 文件中。

当 App 可见时，这个阈值是 5 个保留实例，当 App 不可见时，这个阈值是 1 个保留实例。

##### 3. 泄漏踪迹

LeakCanary 会解析 hprof 文件，并且找出导致 GC 无法回收实例的引用链，这也就是泄漏踪迹（Leak Trace）。

泄漏踪迹也叫最短强引用路径，这个路径是 GC Roots 到实例的路径。

##### 4. 泄漏分组

当有两个泄漏分析结果相同时，LeakCanary 会根据子引用链来判断它们是否是同一个原因导致的，如果是的话，LeakCanary 会把它们归为同一组，以免重复显示同样的泄漏信息。

10. 安装 LeakCanary

##### 1. AndroidX 项目

首先添加添加依赖。

dependencies {
// 使用 debugImplementation 是因为 LeakCanary 一般不用于发布版本
debugImplementation ‘com.squareup.leakcanary:leakcanary-android:2.0-alpha-3’
}

LeakCanary 默认只监控 Activity 实例是否泄漏，如果我们想监控其他的对象是否也泄漏，就要使用 RefWatcher。

// 1. 在 Application 中定义一个 RefWatcher 的静态变量
companion object {
val refWatcher = LeakSentry.refWatcher
}

// 2. 使用 RefWatcher 监控该对象
MyApplication.refWatcher.watch(object);

配置监控选项。

private fun initLeakCanary() {
LeakSentry.config = LeakSentry.config.copy(watchActivities = false)
}

##### 2. 非 AndroidX 项目

添加依赖。

dependencies {
debugImplementation ‘com.squareup.leakcanary:leakcanary-android:1.6.3’
releaseImplementation ‘com.squareup.leakcanary:leakcanary-android-no-op:1.6.3’
// 只有在你使用了 support library fragments 的时候才需要下面这一项
debugImplementation ‘com.squareup.leakcanary:leakcanary-support-fragment:1.6.3’
}

初始化 LeakCanary。

public class MyApplication extends Application {

@Override public void onCreate() {
super.onCreate();
// 不需要在 LeakCanary 用来做堆分析的进程中初始化 LeakCanary
if (!LeakCanary.isInAnalyzerProcess(this)) {
LeakCanary.install(this);
return;
}
}
}

监控特定对象。

// 1. 在 Application 中定义一个获取 RefWatcher 的静态方法
public static RefWatcher getRefWatcher() {
return LeakCanary.installedRefWatcher();
}

// 2. 使用 RefWatcher 监控该对象
MyApplication.getRefWatcher().watch(object);

配置监控选项。

public class MyApplication extends Application {
private void installLeakCanary() {
RefWatcher refWatcher = LeakCanary.refWatcher(this)
.watchActivities(false)
.buildAndInstall();
}
}

当安装完成，并且重新安装了应用后，我们可以在桌面看到 LeakCanary 用于分析内存泄漏的应用。

下面这两张图中，第一个是 LeakCanary 为非 AndroidX 项目安装的应用，第二个是 LeakCanary 为 AndroidX 项目安装的应用。

10.3 使用 LeakCanary 分析内存泄漏

下面是一个静态变量持有 Activity 导致 Activity 无法被释放的一个例子。

public class MemoryLeakActivity extends AppCompatActivity {

public static List activities = new ArrayList<>();

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
activities.add(this);
}
}

我们可以在 Logcat 中看到泄漏实例的引用链。

除了 Logcat，我们还可以在 Leaks App 中看到引用链。

点击桌面上 LeakCanary 为我们安装的 Leaks 应用后，可以看到 activities 变量，之所以在这里会显示这个变量，是因为 LeakCanary 分析的结果是这个变量持有了某个实例，导致该实例无法被回收。

点击这一项泄漏信息，我们可以看到一个泄漏信息概览页。

我们点击第一项 MemoryActivity Leaked，可以看到泄漏引用链的详情。

通过上面这些步骤，很简单地就能找到 LeakCanary 为我们分析的导致内存泄漏的地方。

11. 获取和监听系统内存状态

Android 提供了两种方式让我们可以监听系统内存状态，下面我们就来看看这两种方式的用法。

1. ComponentCallback2

在 Android 4.0 后，Android 应用可以通过在 Activity 中实现 ComponentCallback2 接口获取系统内存的相关事件，这样就能在系统内存不足时提前知道这件事，提前做出释放内存的操作，避免我们自己的应用被系统干掉。

ComponentCallnback2 提供了 onTrimMemory(level) 回调方法，在这个方法里我们可以针对不同的事件做出不同的释放内存操作。

import android.content.ComponentCallbacks2

class MainActivity : AppCompatActivity(), ComponentCallbacks2 {

/**

• 当应用处于后台或系统资源紧张时，我们可以在这里方法中释放资源，
• 避免被系统将我们的应用进行回收
• @param level 内存相关事件
  */
  override fun onTrimMemory(level: Int) {

// 根据不同的应用生命周期和系统事件进行不同的操作
when (level) {

// 应用界面处于后台
ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN -> {
// 可以在这里释放 UI 对象
}

// 应用正常运行中，不会被杀掉，但是系统内存已经有点低了
ComponentCallbacks2.TRIM_MEMORY_RUNNING_MODERATE,

// 应用正常运行中，不会被杀掉，但是系统内存已经非常低了，
// 这时候应该释放一些不必要的资源以提升系统性能
ComponentCallbacks2.TRIM_MEMORY_RUNNING_LOW,

// 应用正常运行，但是系统内存非常紧张，
// 系统已经开始根据 LRU 缓存杀掉了大部分缓存的进程
// 这时候我们要释放所有不必要的资源，不然系统可能会继续杀掉所有缓存中的进程
ComponentCallbacks2.TRIM_MEMORY_RUNNING_CRITICAL -> {
// 释放资源
}

// 系统内存很低，系统准备开始根据 LRU 缓存清理进程，
// 这时我们的程序在 LRU 缓存列表的最近位置，不太可能被清理掉，
// 但是也要去释放一些比较容易恢复的资源，让系统内存变得充足
ComponentCallbacks2.TRIM_MEMORY_BACKGROUND,

// 系统内存很低，并且我们的应用处于 LRU 列表的中间位置，
// 这时候如果还不释放一些不必要资源，那么我们的应用可能会被系统干掉
ComponentCallbacks2.TRIM_MEMORY_MODERATE,

// 系统内存非常低，并且我们的应用处于 LRU 列表的最边缘位置，
// 系统会有限考虑干掉我们的应用，如果想活下来，就要把所有能释放的资源都释放了
ComponentCallbacks2.TRIM_MEMORY_COMPLETE -> {
/*

• 把所有能释放的资源都释放了
  */
  }

// 应用从系统接收到一个无法识别的内存等级值，
// 跟一般的低内存消息提醒一样对待这个事件

else -> {
// 释放所有不重要的数据结构。
}
}
}
}

2. ActivityManager.getMemoryInfo()

Android 提供了一个 ActivityManager.getMemoryInfo() 方法给我们查询内存信息，这个方法会返回一个 ActivityManager.MemoryInfo 对象，这个对象包含了系统当前内存状态，这些状态信息包括可用内存、总内存以及低杀内存阈值。

MemoryInfo 中包含了一个 lowMemory 布尔值，这个布尔值用于表明系统是否处于低内存状态。

fun doSomethingMemoryIntensive() {
// 在做一些需要很多内存的任务前，
// 检查设备是否处于低内存状态、
if (!getAvailableMemory().lowMemory) {
// 做需要很多内存的任务
}
}

// 获取 MemoryInfo 对象
private fun getAvailableMemory(): ActivityManager.MemoryInfo {
val activityManager = getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
return ActivityManager.MemoryInfo().also { memoryInfo ->
activityManager.getMemoryInfo(memoryInfo)
}
}

12. 七个内存优化技巧

1. 谨慎使用 Service

让一个没用的 Service 在后台运行对于一个应用的内存管理来说是一件最糟糕的事情。

要在 Service 的任务完成后停止它，不然 Service 占用的这块内存会泄漏。

当你的应用中运行着一个 Service，除非系统内存不足，否则它不会被干掉。

这就导致对于系统来说 Service 的运行成本很高，因为 Service 占用的内存其他的进程是不能使用的。

Android 有一个缓存进程列表，当可用内存减少时，这个列表也会随之缩小，这就会导致应用间的切换变得很慢。

如果我们是用 Service 监听一些系统广播，可以考虑使用 JobScheduler。

如果你真的要用 Service，可以考虑使用 IntentService，IntentService 是 Service 的一个子类，在它的内部有一个工作线程来处理耗时任务，当任务执行完后，IntentService 就会自动停止。

2. 选择优化后的数据容器

Java 提供的部分数据容器并不适合 Android，比如 HashMap，HashMap 需要中存储每一个键值对都需要一个额外的 Entry 对象。

Android 提供了几个优化后的数据容器，包括 SparseArray、SparseBooleanArray 以及 LongSparseArray。

SparseArray 之所以更高效，是因为它的设计是只能使用整型作为 key，这样就避免了自动装箱的开销。

3. 小心代码抽象

抽象可以优化代码的灵活性和可维护性，但是抽象也会带来其他成本。

抽象会导致更多的代码需要被执行，也就是需要更多的时间和把更多的代码映射到内存中。

如果某段抽象代码带来的好处不大，比如一个地方可以直接实现而不需要用到接口的，那就不用接口。

4. 使用 protobuf 作为序列化数据

Protocol buffers 是 Google 设计的，它可以对结构化的数据序列化，与 XML 类似，不过比 XML 更小，更快，而且更简单。

如果你决定使用 protobuf 作为序列化数据格式，那在客户端代码中应该使用轻量级的 protobuf。

因为一般的 protobuf 会生成冗长的代码，这样会导致内存增加、APK 大小增加，执行速度变慢等问题。

更多关于 protobuf 的信息可以查看 protobuf readme 中的 “轻量级版本” 。

5. Apk 瘦身

有些资源和第三方库会在我们不知情的情况下大量消耗内存。

Bitmap 大小、资源、动画以及第三方库会影响到 APK 的大小，Android Studio 提供了 R8 和 ProGuard 帮助我们缩小 Apk，去掉不必要的资源。

如果你使用的 Android Studio 版本是 3.3 以下的，可以使用 ProGuard，3.3 及以上版本的可以使用 R8。

6. 使用 Dagger2 进行依赖注入

依赖注入框架不仅可以简化我们的代码，而且能让我们在测试代码的时候更方便。

最后

在这里我和身边一些朋友特意整理了一份快速进阶为Android高级工程师的系统且全面的学习资料。涵盖了Android初级——Android高级架构师进阶必备的一些学习技能。

附上：我们之前因为秋招收集的二十套一二线互联网公司Android面试真题（含BAT、小米、华为、美团、滴滴）和我自己整理Android复习笔记（包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总。）

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

我们在测试代码的时候更方便。

最后

在这里我和身边一些朋友特意整理了一份快速进阶为Android高级工程师的系统且全面的学习资料。涵盖了Android初级——Android高级架构师进阶必备的一些学习技能。

附上：我们之前因为秋招收集的二十套一二线互联网公司Android面试真题（含BAT、小米、华为、美团、滴滴）和我自己整理Android复习笔记（包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总。）
[外链图片转存中…(img-W7dMLVgr-1715461043448)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！