Android 性能优化最佳实践，面试必问
那么什么情况下会出现这样的对象呢？ 基本可以分为以下四大类： 1、集合类泄漏 2、单例/静态变量造成的内存泄漏 3、匿名内部类/非静态内部类 4、资源未关闭造成的内存泄漏
1、集合类泄漏
集合类添加元素后，仍引用着集合元素对象，导致该集合中的元素对象无法被回收，从而导致内存泄露。
举个栗子：
static List<Object> mList = new ArrayList<>();
for (int i = 0; i < 100; i++) {
Object obj = new Object();
mList.add(obj);
obj = null;
}
当 mList 没用的时候，我们如果不做处理的话，这就是典型的占着茅坑不拉屎，mList 内部持有者众多集合元素的对象，不泄露天理难容啊。解决这个问题也超级简单。把 mList 清理掉，然后把它的引用也给释放掉。
mList.clear();
mList = null;
2、单例/静态变量造成的内存泄漏
单例模式具有其 静态特性，它的生命周期 等于应用程序的生命周期，正是因为这一点，往往很容易造成内存泄漏。 先来一个小栗子：
public class SingleInstance {
private static SingleInstance mInstance;
private Context mContext;
private SingleInstance(Context context){
this.mContext = context;
}
public static SingleInstance newInstance(Context context){
if(mInstance == null){
mInstance = new SingleInstance(context);
}
return sInstance;
}
}
当我们在 Activity 里面使用这个的时候，把我们 Acitivty 的 context 传进去，那么，这个单例就持有这个 Activity 的引用，当这个 Activity 没有用了，需要销毁的时候，因为这个单例还持有 Activity 的引用，所以无法 GC 回收，所以就出现了内存泄漏，也就是生命周期长的持有了生命周期短的引用，造成了内存泄漏。
所以我们要做的就是生命周期长的和生命周期长的玩，短的和短的玩。就好比你去商场，本来就是传个话的，话说完就要走了，突然保安过来非要拉着你的手，说要和你天长地久。只要商场在一天，他就要陪你一天。天呢？太可怕了。叔叔我们不约，我有我的小伙伴，我还要上学呢，你赶紧找你的保洁阿姨去吧。你在商场的生命周期本来可能就是 1 分钟，而保安的生命周期那是要和商场开关门一致的，所以不同生命周期的最好别一起玩的好。
解决方案也很简单：
public class SingleInstance {
private static SingleInstance mInstance;
private Context mContext;
private SingleInstance(Context context){
this.mContext = context.getApplicationContext();
}
public static SingleInstance newInstance(Context context){
if(mInstance == null){
mInstance = new SingleInstance(context);
}
return sInstance;
}
}
还有一个常用的地方就是 Toast。你应该知道和谁玩了吧。
3、匿名内部类/非静态内部类
这里有一张宝图：
非静态内部类他会持有他外部类的引用，从图我们可以看到非静态内部类的生命周期可能比外部类更长，这就是二楼的情况一致了，如果非静态内部类的周明周期长于外部类，在加上自动持有外部类的强引用，我的乖乖，想不泄漏都难啊。
我们再来举个栗子：
public class TestActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_test);
new MyAscnyT
ask().execute();
}
class MyAscnyTask extends AsyncTask<Void, Integer, String>{
@Override
protected String doInBackground(Void... params) {
try {
Thread.sleep(100000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "";
}
}
}
我们经常会用这个方法去异步加载，然后更新数据。貌似很平常，我们开始学这个的时候就是这么写的，没发现有问题啊，但是你这么想一想，MyAscnyTask 是一个非静态内部类，如果他处理数据的时间很长，极端点我们用 sleep 100 秒，在这期间 Activity 可能早就关闭了，本来 Activity 的内存应该被回收的，但是我们知道非静态内部类会持有外部类的引用，所以 Activity 也需要陪着非静态内部类 MyAscnyTask 一起天荒地老。好了，内存泄漏就形成了。
怎么办呢？
既然 MyAscnyTask 的生命周期可能比较长，那就把它变成静态，和 Application 玩去吧，这样 MyAscnyTask 就不会再持有外部类的引用了。两者也相互独立了。
public class TestActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_test);
new MyAscnyTask().execute();
}
//改了这里 注意一下 static
static class MyAscnyTask extends AsyncTask<Void, Integer, String>{
@Override
protected String doInBackground(Void... params) {
try {
Thread.sleep(100000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "";
}
}
}
说完非静态内部类，我再来看看匿名内部类，这个问题很常见，匿名内部类和非静态内部类有一个共同的地方，就是会只有外部类的强引用，所以这哥俩本质是一样的。但是处理方法有些不一样。但是思路绝对一样。换汤不换药。
举个灰常熟悉的栗子：
public class TestActivity extends Activity {
private TextView mText;
private Handler mHandler = new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
//do something
mText.setText(" do someThing");
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_test);
mText = findVIewById(R.id.mText);
// 匿名线程持有 Activity 的引用，进行耗时操作
new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(100000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
mHandler. sendEmptyMessageDelayed(0, 100000);
}
想必这两个方法是我们经常用的吧，很熟悉，也是这么学的，没感觉不对啊，老师就是这么教的，通过我们上面的分析，还这么想吗？关键是 耗时时间过长，造成内部类的生命周期大于外部类，对弈非静态内部类，我们可以静态化，至于匿名内部类怎么办呢？一样把它变成静态内部类，也就是说尽量不要用匿名内部类。完事了吗？很多人不注意这么一件事，如果我们在 handleMessage 方法里进行 UI 的更新，这个 Handler 静态化了和 Activity 没啥关系了，但是比如这个 mText，怎么说？全写是 activity.mText，看到了吧，持有了 Activity 的引用，也就是说 Handler 费劲心思变成静态类，自认为不持有 Activity 的引用了，准确的说是不自动持有 Activity 的引用了，但是我们要做 UI 更新的时候势必会持有 Activity 的引用，静态类持有非静态类的引用，我们发现怎么又开始内存泄漏了呢？处处是坑啊，怎么办呢？我们这里就要引出弱引用的概念了。
引用分为强引用，软引用，弱引用，虚引用，强度一次递减。
强引用 我们平时不做特殊处理的一般都是强引用，如果一个对象具有强引用，GC 宁可 OOM 也绝不会回收它。看出多强硬了吧。
软引用(SoftReference) 如果内存空间足够，GC 就不会回收它，如果内存空间不足了，就会回收这些对象的内存。
弱引用（WeakReference） 弱引用要比软引用,更弱一个级别，内存不够要回收他，GC 的时候不管内存够不够也要回收他，简直是弱的一匹。不过 GC 是一个优先级很低的线程，也不是太频繁进行，所以弱引用的生活还过得去，没那么提心吊胆。
虚引用 用的甚少，我没有用过，如果想了解的朋友，可以自行谷歌百度。
所以我们用弱引用来修饰 Activity，这样 GC 的时候，该回收的也就回收了，不会再有内存泄漏了。很完美。
public class TestActivity extends Activity {
private TextView mText;
private MyHandler myHandler = new MyHandler(TestActivity.this);
private MyThread myThread = new MyThread();
private static class MyHandler extends Handler {
WeakReference<TestActivity> weakReference;
MyHandler(TestActivity testActivity) {
this.weakReference = new WeakReference<TestActivity>(testActivity);
}
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
weakReference.get().mText.setText("do someThing");
}
}
private static class MyThread extends Thread {
@Override
public void run() {
super.run();
try {
sleep(100000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_test);
mText = findViewById(R.id.mText);
myHandler.sendEmptyMessageDelayed(0, 100000);
myThread.start();
}
//最后清空这些回调
@Override
protected void onDestroy() {
super.onDestroy();
myHandler.removeCallbacksAndMessages(null);
}
4、资源未关闭造成的内存泄漏
网络、文件等流忘记关闭
手动注册广播时，退出时忘记 unregisterReceiver()
Service 执行完后忘记 stopSelf()
EventBus 等观察者模式的框架忘记手动解除注册
这些需要记住又开就有关，具体做法也很简单就不一一赘述了。给大家介绍几个很好用的工具： 1、[leakcanary](
)傻瓜式操作，哪里有泄漏自动给你显示出来，很直接很暴力。 2、我们平时也要多使用 Memory Monitor 进行内存监控，这个分析就有些难度了，可以上网搜一下具体怎么使用。 3、Android Lint 它可以帮助我们发现代码机构 / 质量问题，同时提供一些解决方案，内存泄露的会飘黄，用起来很方便，具体使用方法上网学习，这里不多做说明了。
so
优化 3.0
解决各个情况下的内存泄漏，注意平时代码的规范。
4、启动速度优化
不知道大家有没有细心发现，我们的应用启动要比别的大厂的要慢，要花费更多的时间，明明他们的包体更大，app 更复杂，怎么启动时间反而比我们的短呢？
但是这块的优化关注的人很少，因为 App 常常伴有闪屏页，所以这个问题看起来就不是问题了，但是一款好的应用是绝对不允许这样的，我加闪屏页是我的事，启动速度慢绝对不可以。
app 启动分为冷启动（Cold start）、热启动（Hot start）和温启动（Warm start）三种。
冷启动（Cold start）
冷启动是指应用程序从头开始：系统的进程在此开始之前没有创建应用程序。冷启动发生在诸如自设备启动以来首次启动应用程序或自系统终止应用程序以来。
在冷启动开始时，系统有三个任务。这些任务是： 1、加载并启动应用程序 2、启动后立即显示应用程序的空白启动窗口 3、创建应用程序进程
当系统为我们创建了应用进程之后，开始创建应用程序对象。
1、启动主线程 2、创建主 Activity 3、加载布局 4、屏幕布局 5、执行初始绘制
应用程序进程完成第一次绘制后，系统进程会交换当前显示的背景窗口，将其替换为主活动。此时，用户可以开始使用该应用程序。至此启动完成。
Application 创建
当 Application 启动时，空白的启动窗口将保留在屏幕上，直到系统首次完成绘制应用程序。此时，系统进程会交换应用程序的启动窗口，允许用户开始与应用程序进行交互。这就是为什么我们的程序启动时会先出现一段时间的黑屏(白屏)。
如果我们有自己的 Application，系统会onCreate()在我们的 Application 对象上调用该方法。之后，应用程序会生成主线程（也称为 UI 线程），并通过创建主要活动来执行任务。
从这一点开始，App 就按照他的 [应用程序生命周期阶段进行](
)。
Activity 创建
应用程序进程创建活动后，活动将执行以下操作：
初始化值。
调用构造函数。
调用回调方法，例如 [Activity.onCreate()](
)，对应 Activity 的当前生命周期状态。
通常，该 [onCreate()](
)方法对加载时间的影响最大，因为它以最高的开销执行工作：加载和膨胀视图，以及初始化活动运行所需的对象。
热启动（Hot start）
应用程序的热启动比冷启动要简单得多，开销也更低。在一个热启动中，系统都会把你的 Activity 带到前台。如果应用程序的 Activity 仍然驻留在内存中，那么应用程序可以避免重复对象初始化、布局加载和渲染。
热启动显示与冷启动方案相同的屏幕行为：系统进程显示空白屏幕，直到应用程序完成呈现活动。
温启动（Warm start）
温启动包含了冷启动时发生的一些操作，与此同时，它表示的开销比热启动少，有许多潜在的状态可以被认为是温暖的开始。
场景：
用户退出您的应用，但随后重新启动它。该过程可能已继续运行，但应用程序必须通过调用从头开始重新创建 Activity 的[onCreate()](
)。
系统将您的应用程序从内存中逐出，然后用户重新启动它。需要重新启动进程和活动，但是在调用 onCreate()的时候可以从 Bundle（savedInstanceState）获取数据。
了解完启动过程，我们就知道哪里会影响我们启动的速度了。在创建应用程序和创建 Activity 期间都可能会出现性能问题。
这里是慢的定义：
[冷](
)启动需要 5 秒或更长时间。
[温](
)启动需要 2 秒或更长时间。
[热](
)启动需要 1.5 秒或更长时间。
无论何种启动，我们的优化点都是： Application、Activity 创建以及回调等过程
谷歌官方给的建议是： 1、利用提前展示出来的 Window，快速展示出来一个界面，给用户快速反馈的体验； 2、避免在启动时做密集沉重的初始化（Heavy app initialization）； 3、避免 I/O 操作、反序列化、网络操作、布局嵌套等。
具体做法：
针对 1：利用提前展示出来的 Window，快速展示出来一个界面
使用 Activity 的 windowBackground 主题属性来为启动的 Activity 提供一个简单的 drawable。
Layout XML file:
<layer-list xmlns:android="http://schemas.android.com/apk/res/android" android:opacity="opaque">
<item android:drawable="@android:color/white"/>
<item>
<bitmap
android:src="@drawable/product_logo_144dp"
android:gravity="center"/>
</item>
</layer-list>
Manifest file:
<activity ...
android:theme="@style/AppTheme.Launcher" />
这样在启动的时候，会先展示一个界面，这个界面就是 Manifest 中设置的 Style，等 Activity 加载完毕后，再去加载 Activity 的界面，而在 Activity 的界面中，我们将主题重新设置为正常的主题，从而产生一种快的感觉。其实就是个障眼法而已，提前让你看到了假的界面。也算是一种不错的方法，但是治标不治本。
针对 2：避免在启动时做密集沉重的初始化
我们审视一下我们的 MyApplication 里面的操作。初始化操作有友盟，百度，bugly，数据库，IM，神策，图片加载库，网络请求库，广告 sdk，地图，推送，等等，这么多需要初始化，Application 的任务太重了，启动不慢才怪呢。
怎么办呢？这些还都是必要的，不能不去初始化啊，那就只能异步加载了。但是并不是所有的都可以进行异步处理。这里分情况给出一些建议： 1、比如像友盟，bugly 这样的业务非必要的可以的异步加载。 2、比如地图，推送等，非第一时间需要的可以在主线程做延时启动。当程序已经启动起来之后，在进行初始化。 3、对于图片，网络请求框架必须在主线程里初始化了。
同时因为我们一般会有闪屏页面，也可以把延时启动的地图，推动的启动在这个时间段里，这样合理安排时间片的使用。极大的提高了启动速度。
针对 3：避免 I/O 操作、反序列化、网络操作、布局嵌套等。
这个不用多说了，大家应该知道如何去做了，有些上文也有说明。
so
优化 4.0
利用提前展示出来的 Window，快速展示出来一个界面，给用户快速反馈的体验；
避免在启动时做密集沉重的初始化（Heavy app initialization）；
避免 I/O 操作、反序列化、网络操作、布局嵌套等。
5、包体优化
我做过两年的海外应用产品，深知包体大小对于产品新增的影响，包体小百分之五，可能新增就增加百分之五。如果产品基数很大，这个提升就更可怕了。不管怎么说，我们要减肥，要六块腹肌，不要九九归一的大肚子。
既然要瘦身，那么我们必须知道 APK 的文件构成，解压 apk：
assets 文件夹 存放一些配置文件、资源文件，assets 不会自动生成对应的 ID，而是通过 AssetManager 类的接口获取。
res 目录 res 是 resource 的缩写，这个目录存放资源文件，会自动生成对应的 ID 并映射到 .R 文件中，访问直接使用资源 ID。
META-INF 保存应用的签名信息，签名信息可以验证 APK 文件的完整性。
AndroidManifest.xml 这个文件用来描述 Android 应用的配置信息，一些组件的注册信息、可使用权限等。
classes.dex Dalvik 字节码程序，让 Dalvik 虚拟机可执行，一般情况下，Android 应用在打包时通过 Android SDK 中的 dx 工具将 Java 字节码转换为 Dalvik 字节码。
resources.arsc 记录着资源文件和资源 ID 之间的映射关系，用来根据资源 ID 寻找资源。
我们需要从代码和资源两个方面去减少响应的大小。
1、首先我们可以使用[lint](
)工具，如果有没有使用过的资源就会打印如下的信息(不会使用的朋友可以上网看一下)
res/layout/preferences.xml: Warning: The resource R.layout.preferences appears
to be unused [UnusedResources]
同时我们可以开启资源压缩,自动删除无用的资源
android {
...
buildTypes {
release {
shrinkResources true
minifyEnabled true
proguardFiles getDefaultProguardFile('proguard-android.txt'),
'proguard-rules.pro'
}
}
无用的资源已经被删除了，接下来哪里可以在瘦身呢？
2、我们可以使用可绘制对象，某些图像不需要静态图像资源; 框架可以在运行时动态绘制图像。[Drawable](
)对象（<shape>以 XML 格式）可以占用 APK 中的少量空间。此外，XML [Drawable](
)对象产生符合材料设计准则的单色图像。
上面的话官方，简单说来就是，能自己用 XML 写 Drawable，就自己写，能不用公司的 UI 切图，就别和他们说话，咱们自己造，做自己的 UI，美滋滋。而且这种图片占用空间会很小。
3、重用资源，比如一个三角按钮，点击前三角朝上代表收起的意思，点击后三角朝下，代表展开，一般情况下，我们会用两张图来切换，我们完全可以用旋转的形式去改变
<?xml version="1.0" encoding="utf-8"?>
<rotate xmlns:android="http://schemas.android.com/apk/res/android"
android:drawable="@drawable/ic_thumb_up"
android:pivotX="50%"
android:pivotY="50%"
android:fromDegrees="180" />
比如同一图像的着色不同，我们可以用 android:tint 和 tintMode 属性，低版本（5.0 以下）可以使用[ColorFilter](
)。
4、压缩 PNG 和 JPEG 文件 您可以减少 PNG 文件的大小，而不会丢失使用工具如图像质量 [pngcrush](
)，[pngquant](
)，或[zopflipng](
)。所有这些工具都可以减少 PNG 文件的大小，同时保持感知的图像质量。
5、使用 WebP 文件格式 可以使用图像的[WebP](
)文件格式，而不是使用 PNG 或 JPEG 文件。WebP 格式提供有损压缩（如 JPEG）以及透明度（如 PNG），但可以提供比 JPEG 或 PNG 更好的压缩。
可以使用 Android Studio 将现有的 BMP，JPG，PNG 或静态 GIF 图像转换为 WebP 格式。
6、使用矢量图形 可以使用矢量图形来创建与分辨率无关的图标和其他可伸缩 Image。使用这些图形可以大大减少 APK 大小。一个 100 字节的文件可以生成与屏幕大小相关的清晰图像。
但是，系统渲染每个[VectorDrawable](
)对象需要花费大量时间 ，而较大的图像需要更长的时间才能显示在屏幕上。因此，请考虑仅在显示小图像时使用这些矢量图形。
不要把[AnimationDrawable](
)用于创建逐帧动画，因为这样做需要为动画的每个帧包含一个单独的位图文件，这会大大增加 APK 的大小。
7、代码混淆 使用 proGuard 代码混淆器工具，它包括压缩、优化、混淆等功能。这个大家太熟悉了。不多说了。
android {
buildTypes {
release {
minifyEnabled true
proguardFiles getDefaultProguardFile(‘proguard-android.txt'),
'proguard-rules.pro'
}
}
8、插件化。 比如功能模块放在服务器上，按需下载，可以减少安装包大小。
so
优化 5.0
代码混淆
插件化
资源优化
6、耗电优化
我们可能对耗电优化不怎么感冒，没事，谷歌这方面做得也不咋地，5.0 之后才有像样的方案，讲实话这个优化的优先级没有前面几个那么高，但是我们也要了解一些避免耗电的坑，至于更细的耗电分析可以使用这个[Battery Historian](
)。
Battery Historian 是由 Google 提供的 Android 系统电量分析工具，从手机中导出 bugreport 文件上传至页面，在网页中生成详细的图表数据来展示手机上各模块电量消耗过程，最后通过 App 数据的分析制定出相关的电量优化的方法。
我们来谈一下怎么规避电老虎吧。
谷歌推荐使用 JobScheduler，来调整任务优先级等策略来达到降低损耗的目的。JobScheduler 可以避免频繁的唤醒硬件模块，造成不必要的电量消耗。避免在不合适的时间(例如低电量情况下、弱网络或者移动网络情况下的)执行过多的任务消耗电量。
还未添加个人签名 2021.10.31 加入
还未添加个人简介
评论