探索 Android 内存优化方法

最新推荐文章于 2024-06-25 10:54:01 发布

2401_84132357

最新推荐文章于 2024-06-25 10:54:01 发布

阅读量1k

点赞数 27

分类专栏：程序员文章标签： android

本文链接：https://blog.csdn.net/2401_84132357/article/details/137443118

版权

程序员专栏收录该内容

168 篇文章 0 订阅

订阅专栏

6.2 四种 Bitmap 解码选项

一张图片中每一个像素的大小取决于它的解码选项，而 Android 中能够选择的 Bitmap 解码选项有四种。

下面四种解码选项中的的 ARGB 分别代表透明度和三原色 Alpha、Red、Green、Blue。

ARGB_8888

ARGB 四个通道的值都是 8 位，加起来 32 位，也就是每个像素占 4 个字节

ARGB_4444

ARGB 四个通道的值都是 4 位，加起来 16 位，也就是每个像素占 2 个字节

RGB_565

RGB 三个通道分别是 5 位、6 位、5 位，加起来 16 位，也就是每个像素占 2 个字节

ALPHA_8

只有 A 通道，占 8 位，也就是每个像素占 1 个字节

6.3 不同版本 Bitmap 内存分配方式

在 Android 3.0 之前，Bitmap 对象放在 Java 堆中，像素数据放在 Native 内存中，如果不手动调用 Bitmap 的 recycle() 方法，Bitmap 的 Native 内存的回收就依赖于 finalize() 回调，finalize() 是 Object 类的一个方法，当一个堆空间中的对象没有被栈空间变量指向时，这个对象会等待被 Java 回收，时机不可控

在 Android 3.0~7.0 时，把 Bitmap 对象和像素数据都放在 Java 堆中，就算我们不调用 recycle() 方法，Bitmap 内存也会随着对象一起被回收。不过 Bitmap 是内存消耗的大户，把它放在 Java 堆中就压缩了其他资源的可用内存，而且这么做还会引发大量的 GC ，也没有充分利用系统内存。

在 Android 8.0 时，新增了一个叫 NativeAllocationRegistry 的辅助回收 Native 内存的机制，像素放在了 Native 内存中，而且还新增了可以减少图片内存并提升绘制效率的硬件位图 Hardware Bitmap ，做到了 Bitmap 的 Native 内存可和对象一起快速释放，而且 GC 时会避免这些内存被滥用，

6.4 Glide

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

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

7. 内存泄漏与内存抖动

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

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

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

内存泄漏png

常见的导致内存泄漏的 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 资源未释放

忘了注销 BroadcastReceiver
忘了关闭数据库游标（Cursor）
忘了关闭流
忘了调用 recycle() 方法回收创建的 Bitmap 使用的内存
忘了在 Activity 退出时取消 RxJava 或协程所开启异步任务
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 有下面三种方式。

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

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

Profiler

开了高级选项后，我们在 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 及以下版本的设备中才能使用。

堆转储png

3. 查看内存分配详情

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

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

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

查看内存分配png

9. Memory Analyzer Tool

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

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

1. MAT 使用步骤

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

到 MAT 的官网下载 MAT。
使用 Memory Profiler 的堆转储功能，导出 hprof（Heap Profile）文件。
配置 platform-tools 环境变量
使用命令将 Memory Profiler 中导出来的 hprof 文件转换为 MAT 可以解析的 hprof 文件，命令如下

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

打开 MAT
File > open Heap dump ，选择我们转换后的文件

2. 注意事项

如果在 mac 上打不开 MAT，可以参考Eclipse Memory Analyzer在Mac启动报错
如果在 mac 上配置 platform-tools 不成功的话，可以直接定位到 Android SDK 下的 platform-tools 目录，直接使用 hprof-conv 工具，命令如下

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

3. 分析内存泄漏

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

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

MAT 预览页png

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

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

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

MAT 实例列表png

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

MAT 查看引用

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

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 项目安装的应用。

内存泄漏进程png

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 中看到泄漏实例的引用链。

Locat 内存泄漏信息

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

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

Leaks1png

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

Leaks2

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

Leaks3png

通过上面这些步骤，很简单地就能找到 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 进行依赖注入

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

如果我们想在应用中使用依赖注入，可以考虑使用 Dagger2。

Dagger2 是在编译期生成代码，而不是用反射实现的，这样就避免了反射带来的内存开销，而是在编译期生成代码，

7. 谨慎使用第三方库

当你决定使用一个不是为移动平台设计的第三方库时，你需要对它进行优化，让它能更好地在移动设备上运行，这些第三方库包括日志、分析、图片加载、缓存以及其他框架，都有可能带来性能问题。

参考资料

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

最后

简历首选内推方式，速度快，效率高啊！然后可以在拉钩，boss，脉脉，大街上看看。简历上写道熟悉什么技术就一定要去熟悉它，不然被问到不会很尴尬！做过什么项目，即使项目体量不大，但也一定要熟悉实现原理！不是你负责的部分，也可以看看同事是怎么实现的，换你来做你会怎么做？做过什么，会什么是广度问题，取决于项目内容。但做过什么，达到怎样一个境界，这是深度问题，和个人学习能力和解决问题的态度有关了。大公司看深度，小公司看广度。大公司面试你会的，小公司面试他们用到的你会不会，也就是岗位匹配度。

选定你想去的几家公司后，先去一些小的公司练练，学习下面试技巧，总结下，也算是熟悉下面试氛围，平时和同事或者产品PK时可以讲得头头是道，思路清晰至极，到了现场真的不一样，怎么描述你所做的一切，这绝对是个学术性问题！

面试过程一定要有礼貌！即使你觉得面试官不尊重你，经常打断你的讲解，或者你觉得他不如你，问的问题缺乏专业水平，你也一定要尊重他，谁叫现在是他选择你，等你拿到offer后就是你选择他了。

金九银十面试季，跳槽季，整理面试题已经成了我多年的习惯！在这里我和身边一些朋友特意整理了一份快速进阶为Android高级工程师的系统且全面的学习资料。涵盖了Android初级——Android高级架构师进阶必备的一些学习技能。

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

《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》，点击传送门即可获取！

先去一些小的公司练练，学习下面试技巧，总结下，也算是熟悉下面试氛围，平时和同事或者产品PK时可以讲得头头是道，思路清晰至极，到了现场真的不一样，怎么描述你所做的一切，这绝对是个学术性问题！

[外链图片转存中…(img-gQ7PcNAa-1712422764771)]

《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》，点击传送门即可获取！

2401_84132357

关注

27
点赞
踩
16

收藏

觉得还不错? 一键收藏
0
评论
探索 Android 内存优化方法

MAT和LeakCanary，下面先来看下 Memory Profiler。Memory Profiler 是 Profiler 中的其中一个版块，Profiler 是 Android Studio 为我们提供的性能分析工具，使用 Profiler 能分析应用的 CPU、内存、网络以及电量的使用情况。打开 Profiler 有下面三种方式。下方的 Profiler 标签双击 shift 搜索 profiler。
复制链接

扫一扫