android内存策略,Android内存优化分析

1.内存分配策略

对象 / 变量的内存分配 由程序自动 负责

共有3种：静态分配、栈式分配、 & 堆式分配，分别面向静态变量、局部变量 & 对象实例

具体介绍如下

memory_tenet.jpg

用一个实例讲解 内存分配

public class Sample {

// 该类的实例对象的成员变量s1、mSample1 & 指向对象存放在堆内存中

int s1 = 0;

Sample mSample1 = new Sample();

// 方法中的局部变量s2、mSample2存放在 栈内存

// 变量mSample2所指向的对象实例存放在 堆内存

public void method() {

int s2 = 0;

Sample mSample2 = new Sample();

}

}

// 变量mSample3的引用存放在栈内存中

// 变量mSample3所指向的对象实例存放在堆内存

// 该实例的成员变量s1、mSample1也存放在堆内存中

Sample mSample3 = new Sample();

2.内存释放策略

对象 / 变量的内存释放 由Java垃圾回收器(GC) / 帧栈 负责

此处主要讲解对象分配(即堆式分配)的内存释放策略 = Java垃圾回收器(GC)

Java垃圾回收器(GC)的内存释放 = 垃圾回收算法，主要包括：

1，标记清除算法

image-20200622152612023.png

2，复制算法

image-20200622152649280.png

3，标记压缩算法

image-20200622152724291.png

4，分代收集算法

image-20200622153025818.png

具体介绍如下

memory.jpg

3.常见的内存问题&优化方案

常见的内存问题如下

​ 1.内存泄漏

​ 2.内存抖动

​ 3.图片Bitmap相关

​ 4.代码质量&数量

​ 5.日常不正确使用

3.1内存泄漏

简介 ：指 程序在申请内存后，当该内存不需再使用 但 却无法被释放 & 归还给 程序的现象

对应用程序的影响 ：内存溢出

oom.jpg

发生内存泄漏的本质原因

oom_reson.jpg

常见内存泄漏原因

​ 1.集合类

​ 2.static关键字修饰的成员变量

​ 3.非静态内部类/匿名类

​ 4.资源对象使用后未关闭

3.2优化方案

1.集合类

内存泄漏原因

集合类添加元素后，仍引用着 集合元素对象，导致该集合元素对象不可被回收，从而 导致内存泄漏

实例演示

// 通过 循环申请Object 对象 & 将申请的对象逐个放入到集合List

List objectList = new ArrayList<>();

for (int i = 0; i < 10; i++) {

Object o = new Object();

objectList.add(o);

o = null;

}

// 虽释放了集合元素引用的本身：o=null)

// 但集合List 仍然引用该对象，故垃圾回收器GC 依然不可回收该对象

解决方案

集合类 添加集合元素对象 后，在使用后必须从集合中删除

// 释放objectList

objectList.clear();

objectList=null;

2.Static关键字修饰的成员变量

储备知识

被static关键字修饰的成员变量的生命周期 = 应用程序的生命周期

泄漏原因

若使被 Static 关键字修饰的成员变量 引用耗费资源过多的实例(如Context)，则容易出现该成员变量的生命周期 > 引用实例生命周期的情况，当引用实例需结束生命周期销毁时，会因静态变量的持有而无法被回收，从而出现内存泄露

实例讲解

public class ClassName {

// 定义1个静态变量

private static Context mContext;

//...

// 引用的是Activity的context

mContext = context;

// 当Activity需销毁时，由于mContext = 静态 & 生命周期 = 应用程序的生命周期，故 Activity无法被回收，从而出现内存泄露

}

解决方案

1.尽量避免static成员变量引用资源耗费过多的实例(如Context),若需引用Context,则尽量使用Applicaiton的Context

2.使用弱引用(WeakReference)代替强引用持有实例

注：静态成员变量有个非常典型的例子 = 单例模式

储备知识

单例模式 由于其静态特性，其生命周期的长度 = 应用程序的生命周期

泄漏原因

若1个对象已不需再使用 而单例对象还持有该对象的引用，那么该对象将不能被正常回收 从而 导致内存泄漏

实例演示

// 创建单例时，需传入一个Context

// 若传入的是Activity的Context，此时单例 则持有该Activity的引用

// 由于单例一直持有该Activity的引用(直到整个应用生命周期结束)，即使该Activity退出，该Activity的内存也不会被回收

// 特别是一些庞大的Activity，此处非常容易导致OOM

public class SingleInstanceClass {

private static SingleInstanceClass instance;

private Context mContext;

private SingleInstanceClass(Context context) {

this.mContext = context; // 传递的是Activity的context

}

public SingleInstanceClass getInstance(Context context) {

if (instance == null) {

instance = new SingleInstanceClass(context);

}

return instance;

}

}

解决方案

单例模式引用的对象的生命周期 = 应用的生命周期

public class SingleInstanceClass {

private static SingleInstanceClass instance;

private Context mContext;

private SingleInstanceClass(Context context) {

this.mContext = context;

}

public SingleInstanceClass getInstance(Context context) {

if (instance == null) {

instance = new SingleInstanceClass(context.getApplicationContext());// 传递的是Application 的context

}

return instance;

}

}

3.非静态内部类/匿名类

储备知识

非静态内部类/匿名类 默认持有外部类的引用，而静态内部类则不会

常见情况

3种，分别是：非静态内部类的实例 = 静态、多线程、消息传递机制(Handler)

第一种.非静态内部类的实例=静态

泄漏原因

若 非静态内部类所创建的实例 = 静态(其生命周期 = 应用的生命周期)，会因 非静态内部类默认持有外部类的引用 而导致外部类无法释放，最终 造成内存泄露

实例演示

// 背景：

a. 在启动频繁的Activity中，为了避免重复创建相同的数据资源，会在Activity内部创建一个非静态内部类的单例

b. 每次启动Activity时都会使用该单例的数据

public class TestActivity extends AppCompatActivity {

// 非静态内部类的实例的引用

// 注：设置为静态

public static InnerClass innerClass = null;

@Override

protected void onCreate(@Nullable Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

// 保证非静态内部类的实例只有1个

if (innerClass == null)

innerClass = new InnerClass();

}

// 非静态内部类的定义

private class InnerClass {

//...

}

}

// 造成内存泄露的原因：

// a. 当TestActivity销毁时，因非静态内部类单例的引用(innerClass)的生命周期 = 应用App的生命周期、持有外部类TestActivity的引用

// b. 故 TestActivity无法被GC回收，从而导致内存泄漏

解决方案

​ 1.将非静态内部类设置为：静态内部类(静态内部类默认不持有外部类的引用)

​ 2.该内部类抽取出来封装成一个单例

​ 3.尽量 避免 非静态内部类所创建的实例 = 静态

​ 4.若需使用Context,建议使用Application的Context

第二种：多线程：AsyncTask,实现Runnable接口，继承Thread类

储备知识

多线程的使用方法= 非静态内部类/匿名类

泄漏原因

当 工作线程正在处理任务 & 外部类需销毁时， 由于 工作线程实例 持有外部类引用，将使得外部类无法被垃圾回收器(GC)回收，从而造成 内存泄露

实例演示(三者内存泄漏原理相同，这里以Thread类为例说明)

/**

* 方式1：新建Thread子类(内部类)

*/

public class MainActivity extends AppCompatActivity {

public static final String TAG = "carson：";

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

// 通过创建的内部类 实现多线程

new MyThread().start();

}

// 自定义的Thread子类

private class MyThread extends Thread{

@Override

public void run() {

try {

Thread.sleep(5000);

Log.d(TAG, "执行了多线程");

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

/**

* 方式2：匿名Thread内部类

*/

public class MainActivity extends AppCompatActivity {

public static final String TAG = "carson：";

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

// 通过匿名内部类 实现多线程

new Thread() {

@Override

public void run() {

try {

Thread.sleep(5000);

Log.d(TAG, "执行了多线程");

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}.start();

}

}

/**

* 分析：内存泄露原因

*/

// 工作线程Thread类属于非静态内部类 / 匿名内部类，运行时默认持有外部类的引用

// 当工作线程运行时，若外部类MainActivity需销毁

// 由于此时工作线程类实例持有外部类的引用，将使得外部类无法被垃圾回收器(GC)回收，从而造成 内存泄露

解决方案

从上面可看出，造成内存泄漏的原因有2个关键条件：

1.存在“工作线程实例 持有外部类引用”的引用关系

2.工作线程实例的生命周期>外部类的生命周期，即工作线程仍在运行而外部类销毁

解决方案的思路 = 使得上述任一条件不成立即可

// 共有2个解决方案：静态内部类 & 当外部类结束生命周期时，强制结束线程

// 具体描述如下

/**

* 解决方式1：静态内部类

* 原理：静态内部类 不默认持有外部类的引用，从而使得 “工作线程实例 持有 外部类引用” 的引用关系 不复存在

* 具体实现：将Thread的子类设置成 静态内部类

*/

public class MainActivity extends AppCompatActivity {

public static final String TAG = "carson：";

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

// 通过创建的内部类 实现多线程

new MyThread().start();

}

// 分析1：自定义Thread子类

// 设置为：静态内部类

private static class MyThread extends Thread{

@Override

public void run() {

try {

Thread.sleep(5000);

Log.d(TAG, "执行了多线程");

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

/**

* 解决方案2：当外部类结束生命周期时，强制结束线程

* 原理：使得 工作线程实例的生命周期 与 外部类的生命周期 同步

* 具体实现：当 外部类(此处以Activity为例) 结束生命周期时(此时系统会调用onDestroy())，强制结束线程(调用stop())

*/

@Override

protected void onDestroy() {

super.onDestroy();

Thread.stop();

// 外部类Activity生命周期结束时，强制结束线程

}

第三种：消息传递机制：Handler

储备知识

主线程的Looper对象的生命周期 = 该应用程序的生命周期

实例演示

/**

* 方式1：新建Handler子类(内部类)

*/

public class MainActivity extends AppCompatActivity {

public static final String TAG = "carson：";

private Handler showhandler;

// 主线程创建时便自动创建Looper & 对应的MessageQueue

// 之后执行Loop()进入消息循环

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

//1. 实例化自定义的Handler类对象->>分析1

//注：此处并无指定Looper，故自动绑定当前线程(主线程)的Looper、MessageQueue

showhandler = new FHandler();

// 2. 启动子线程1

new Thread() {

@Override

public void run() {

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

// a. 定义要发送的消息

Message msg = Message.obtain();

msg.what = 1;// 消息标识

msg.obj = "AA";// 消息存放

// b. 传入主线程的Handler & 向其MessageQueue发送消息

showhandler.sendMessage(msg);

}

}.start();

// 3. 启动子线程2

new Thread() {

@Override

public void run() {

try {

Thread.sleep(5000);

} catch (InterruptedException e) {

e.printStackTrace();

}

// a. 定义要发送的消息

Message msg = Message.obtain();

msg.what = 2;// 消息标识

msg.obj = "BB";// 消息存放

// b. 传入主线程的Handler & 向其MessageQueue发送消息

showhandler.sendMessage(msg);

}

}.start();

}

// 分析1：自定义Handler子类

class FHandler extends Handler {

// 通过复写handlerMessage() 从而确定更新UI的操作

@Override

public void handleMessage(Message msg) {

switch (msg.what) {

case 1:

Log.d(TAG, "收到线程1的消息");

break;

case 2:

Log.d(TAG, " 收到线程2的消息");

break;

}

}

}

}

/**

* 方式2：匿名Handler内部类

*/

public class MainActivity extends AppCompatActivity {

public static final String TAG = "carson：";

private Handler showhandler;

// 主线程创建时便自动创建Looper & 对应的MessageQueue

// 之后执行Loop()进入消息循环

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

//1. 通过匿名内部类实例化的Handler类对象

//注：此处并无指定Looper，故自动绑定当前线程(主线程)的Looper、MessageQueue

showhandler = new Handler(){

// 通过复写handlerMessage()从而确定更新UI的操作

@Override

public void handleMessage(Message msg) {

switch (msg.what) {

case 1:

Log.d(TAG, "收到线程1的消息");

break;

case 2:

Log.d(TAG, " 收到线程2的消息");

break;

}

}

};

// 2. 启动子线程1

new Thread() {

@Override

public void run() {

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

// a. 定义要发送的消息

Message msg = Message.obtain();

msg.what = 1;// 消息标识

msg.obj = "AA";// 消息存放

// b. 传入主线程的Handler & 向其MessageQueue发送消息

showhandler.sendMessage(msg);

}

}.start();

// 3. 启动子线程2

new Thread() {

@Override

public void run() {

try {

Thread.sleep(5000);

} catch (InterruptedException e) {

e.printStackTrace();

}

// a. 定义要发送的消息

Message msg = Message.obtain();

msg.what = 2;// 消息标识

msg.obj = "BB";// 消息存放

// b. 传入主线程的Handler & 向其MessageQueue发送消息

showhandler.sendMessage(msg);

}

}.start();

}

}

泄漏原因

上述的Handler实例的消息队列有2个分别来自线程1，2的消息。在Handler消息队列还有未处理的消息/正在处理消息时，消息队列中的Message持有Handler实例的引用。由于Handler = 非静态内部类 / 匿名内部类(2种使用方式)，故又默认持有外部类的引用(即MainActivity实例)，引用关系如下图

handler.webp.jpg

在Handler消息队列 还有未处理的消息 / 正在处理消息时，此时若需销毁外部类MainActivity，但由于上述引用关系，垃圾回收器(GC)无法回收MainActivity，从而造成内存泄漏

解决方案

从上面可看出，造成内存泄漏的原因有两个关键条件：

1，存在“未被处理 / 正处理的消息 -> Handler实例 -> 外部类” 的引用关系

2，Handler的生命周期 > 外部类的生命周期

解决方案的思路 = 使得上述任一条件不成立 即可

方案一：静态内部类+弱引用

public class MainActivity extends AppCompatActivity {

public static final String TAG = "carson：";

private Handler showhandler;

// 主线程创建时便自动创建Looper & 对应的MessageQueue

// 之后执行Loop()进入消息循环

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

//1. 实例化自定义的Handler类对象->>分析1

//注：

// a. 此处并无指定Looper，故自动绑定当前线程(主线程)的Looper、MessageQueue；

// b. 定义时需传入持有的Activity实例(弱引用)

showhandler = new FHandler(this);

// 2. 启动子线程1

new Thread() {

@Override

public void run() {

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

// a. 定义要发送的消息

Message msg = Message.obtain();

msg.what = 1;// 消息标识

msg.obj = "AA";// 消息存放

// b. 传入主线程的Handler & 向其MessageQueue发送消息

showhandler.sendMessage(msg);

}

}.start();

// 3. 启动子线程2

new Thread() {

@Override

public void run() {

try {

Thread.sleep(5000);

} catch (InterruptedException e) {

e.printStackTrace();

}

// a. 定义要发送的消息

Message msg = Message.obtain();

msg.what = 2;// 消息标识

msg.obj = "BB";// 消息存放

// b. 传入主线程的Handler & 向其MessageQueue发送消息

showhandler.sendMessage(msg);

}

}.start();

}

// 分析1：自定义Handler子类

// 设置为：静态内部类

private static class FHandler extends Handler{

// 定义 弱引用实例

private WeakReference reference;

// 在构造方法中传入需持有的Activity实例

public FHandler(Activity activity) {

// 使用WeakReference弱引用持有Activity实例

reference = new WeakReference(activity); }

// 通过复写handlerMessage() 从而确定更新UI的操作

@Override

public void handleMessage(Message msg) {

switch (msg.what) {

case 1:

Log.d(TAG, "收到线程1的消息");

break;

case 2:

Log.d(TAG, " 收到线程2的消息");

break;

}

}

}

}

方案二：当外部类结束生命周期时，清空Handler内消息队列

@Override

protected void onDestroy() {

super.onDestroy();

mHandler.removeCallbacksAndMessages(null);

// 外部类Activity生命周期结束时，同时清空消息队列 & 结束Handler生命周期

}

使用建议

为了保证Handler中消息队列中的所有消息都能被执行，此处推荐使用解决方案1解决内存泄露问题，即 静态内部类 + 弱引用的方式

4,资源对象使用后未关闭

泄漏原因

对于资源的使用(如 广播BraodcastReceiver、文件流File、数据库游标Cursor、图片资源Bitmap等)，若在Activity销毁时无及时关闭 / 注销这些资源，则这些资源将不会被回收，从而造成内存泄漏

5，其他使用

除了上述4种常见情况，还有一些日常的使用会导致内存泄漏

主要包括：Context,Webview,Adapter等

other.jpg

3.3总结

总结.jpg

3.4 内存泄漏分析工具

MAT(Memory Analysis Tools)

Heap Viewer

Allocation Tracker

Android Studio 的 Memory Monitor

LeakCanary

3.5 内存抖动

抖动.jpg

优化方案

尽量避免频繁创建大量临时的小对象