Android内存管理基础

·  阅读 461
  • 仅作为个人学习笔记,请小心求证。

内存管理概览:developer.android.com/topic/perfo…
内存分配:developer.android.com/topic/perfo… Android Studio Profiler:developer.android.com/studio/prof…
dalvik-heap:cs.android.com/android/pla…
blog.csdn.net/whbing1471/…
Android系统内存页面:developer.android.com/topic/perfo…

一、内存管理概览

Android 运行时 (ART) 和 Dalvik 虚拟机使用分页内存映射来管理内存。

1.1 内存类型

Android 设备包含三种不同类型的内存:RAM、zRAM 和存储器。请注意,CPU 和 GPU 访问同一个 RAM。 memory-types.svg

  • RAM(Random Access Memory,随机存取存储器) 是最快的内存类型,但其大小通常有限。
  • zRAM 是用于交换空间的 RAM 分区。所有数据在放入 zRAM 时都会进行压缩,然后在从 zRAM 向外复制时进行解压缩。这部分 RAM 会随着页面进出 zRAM 而增大或缩小。设备制造商可以设置 zRAM 大小上限。
  • 存储器中包含所有持久性数据(例如文件系统等),以及为所有应用、库和平台添加的对象代码。在 Android 上,存储器不像在其他 Linux 实现上那样用于交换空间,因为频繁写入会导致这种内存出现损坏,并缩短存储媒介的使用寿命。

1.2 物理内存 虚拟内存

1.2.1 物理内存

物理内存是指真实存在的插在主板内存槽上的内存条的容量,是Android系统中所有进程共享的存储空间;

1.2.2 虚拟内存

当进程申请内存时得到的是虚拟内存,虚拟内存是对物理内存的抽象;每个进程操作的是自己的虚拟内存,并由CPU负责虚拟内存地址与实际物理地址的映射。
500px-Virtual_memory.svg.png

需要注意的是,假如进程没有使用这些虚拟内存,那么不会建立虚拟地址与物理内存的映射。例如:

void main()
{
    for (int i= 0; i < 512; i++)
    {
        malloc(1024 * 1024);
    }
}
// 结果分析:malloc只申请了内存并未使用,因此进程的虚拟内存大小VSZ是539M,而物理内存RSS只有3M。
复制代码

进程在真正使用内存时,虚拟内存与物理内存才建立映射关系,例如:

vector<void*> mems;
void main()
{
    for (int i= 0; i < 512; i++)
    {
        void *p = malloc(1024 * 1024);
        memset(p, 0, 1024 * 1024);
        mems.push_back(p);
    }
}
// 结果分析:用memset对申请的内存执行了写入操作,因此进程的虚拟内存大小VSZ是539M,而物理内存RSS增加到了527M。
复制代码

1.2.3 虚拟内存的好处

(1)使应用程序不必管理共享内存空间;由于所有进程共享物理内存,所以物理内存常常是不连续的,而对应用程序来说,虚拟内存的内存地址是连续的,由CPU负责虚拟内存地址的映射;
(2)能够在进程之间共享库使用的内存;详见1.2.4;
(3)由于内存隔离而提高了安全性;
(4)通过使用分页或分段技术,可使用比物理内存大小更多的内存。

1.2.4 共享库内存

共享库所占内存:同一个共享库的代码在物理内存中只会存在一份,这块内存会映射到不同进程的虚拟内存中,对各个进程来说,就像是自己私有的内存一样,而对于系统来说,则是节省了内存的资源。
Android系统实现跨进程共享RAM页面的方式有:

  • 每个应用进程都从一个名为 Zygote 的现有进程分叉。系统启动并加载通用框架代码和资源(如 Activity 主题背景)时,Zygote 进程随之启动。为启动新的应用进程,系统会分叉 Zygote 进程,然后在新进程中加载并运行应用代码。这种方法使为框架代码和资源分配的大多数 RAM 页面可在所有应用进程之间共享。
  • 大多数静态数据会内存映射到一个进程中。这种方法使得数据不仅可以在进程之间共享,还可以在需要时换出。静态数据示例包括:Dalvik 代码(通过将其放入预先链接的 .odex 文件中进行直接内存映射)、应用资源(通过将资源表格设计为可内存映射的结构以及通过对齐 APK 的 zip 条目)和传统项目元素(如 .so 文件中的原生代码)。
  • 在很多地方,Android 使用明确分配的共享内存区域(通过 ashmem 或 gralloc)在进程间共享同一动态 RAM。例如,窗口 surface 使用在应用和屏幕合成器之间共享的内存,而光标缓冲区则使用在内容提供器和客户端之间共享的内存。

1.3 VSS RSS PSS USS区别

一个进程的内存信息可以用VSS RSS PSS USS来表示,含义如下:
VSS(Virtual Set Size):虚拟内存大小(ps命令用VSZ表示);
RSS(Resident Set Size):常驻内存大小,应用使用的共享和非共享页面的数量;
PSS(Proportional Set Size):按比例分摊的内存大小,应用使用的非共享内存加上共享内存的均匀分摊数量(例如,如果三个进程共享 3MB,则每个进程的 PSS 为 1MB);
USS(Unique Set Size):进程独占用的物理内存(不包含共享库占用的内存); 20200414230206723.png

举例:已知:
(1)共享库libTest.so所占内存共100M,被进程A和进程B共同占用;
(2)进程A申请了100M内存,但是实际使用了60M内存;
则,进程A的VSS=100M+100M=200M; RSS=60M+100M=150M; PSS=60M+100/2=110M; USS=60M;
复制代码

所以,如果想要知道所有进程使用了多少内存,那么可以使用PSS 或 RSS。计算 PSS 需要花很长时间,因为系统需要确定共享的页面以及共享页面的进程数量。RSS 不区分共享和非共享页面(因此计算起来更快),更适合跟踪内存分配量的变化。

1.4 Android系统的页面置换

RAM分为多个“页面”。通常,每个页面为 4KB 的内存。

  • 干净页:存储器中未经修改的文件副本;
  • 脏页:存储器中经过修改的文件副本。

Android系统上,不像在其他 Linux 实现上那样使用ROM存储器用于交换空间,因为频繁写入会导致ROM出现损坏,并缩短存储媒介的使用寿命。
内核交换守护进程 (kswapd) 是 Linux 内核的一部分,用于将已使用内存转换为可用内存。当设备上的可用内存不足时,该守护进程将变为活动状态。Linux 内核设有可用内存上下限阈值。当可用内存降至下限阈值以下时,kswapd 开始回收内存。当可用内存达到上限阈值时,kswapd 停止回收内存。
Android系统使用zRAM用于交换空间,对于私有脏页可由 kswapd 移动到zRAM/在zRAM中进行压缩以增加可用内存,在应用程序需要使用这部分内存时,再从zRAM中取出/在zRAM中解压。详见:内存页面置换策略

二、内存分析方法

2.1 adb常用内存分析命令

2.1.1 ps命令

ps命令可以列出Android系统中当前所有进程的信息:

>adb shell ps
USER           PID  PPID     VSZ    RSS WCHAN            ADDR S NAME           
root             1     0   60588   1360 0                   0 S init
root             2     0   60588   1360 0                   0 S [kthreadd]
root           144     2       0      0 0                   0 S [kswapd0]
root          1034     1 4286332  22916 0                   0 S zygote64
root          1035     1 1616152  25532 0                   0 S zygote
system         570     1   11356   1196 0                   0 S servicemanager
system        1655   958 4786828 277192 0                   0 S system_server
u0_a1166      9742  1035 1716624     20 0                   0 T com.bc.sample
root           727     1    9968   2204 0                   0 S lmkd

>adb shell ps | grep com.bc.sample
u0_a1166      9742  1035 1716624     20 0                   0 T com.bc.sample
复制代码

含义解释:
USER:进程所属用户;
PID:进程ID;
PPID:父进程ID;
VSZ:Virtual Memory Size虚拟内存占用大小,单位:kb
RSS:Resident Set Size物理内存占用大小,单位:kb
NAME:进程名;

2.1.2 dumpsys meminfo

dumpsys meminfo命令可以根据进程名(一般是包名)获取进程当前的内存使用情况:

#命令行输入
>adb shell dumpsys meminfo com.bc.sample
Applications Memory Usage (in Kilobytes):
Uptime: 654784890 Realtime: 2062282674

** MEMINFO in pid 13705 [com.bc.sample] **
                   Pss  Private  Private  SwapPss     Heap     Heap     Heap
                 Total    Dirty    Clean    Dirty     Size    Alloc     Free
                ------   ------   ------   ------   ------   ------   ------
  Native Heap     3445     3396        0       50     7680     6140     1539
  Dalvik Heap      667      612        0       68     2671     1135     1536
 Dalvik Other      360      348        0        0                           
        Stack       48       48        0        0                           
       Ashmem        2        0        0        0                           
      Gfx dev     1664     1576       88        0                           
    Other dev       12        0       12        0                           
     .so mmap     1528      180        0       31                           
    .apk mmap      166        0       28        0                           
    .ttf mmap       58        0        0        0                           
    .dex mmap     3834        4     1744        0                           
    .oat mmap      102        0        0        0                           
    .art mmap     3368     3036        4        7                           
   Other mmap       13        4        0        0                           
   EGL mtrack    18496    18496        0        0                           
    GL mtrack    14964    14964        0        0                           
      Unknown      473      464        0        6                           
        TOTAL    49362    43128     1876      162    10351     7275     3075 

 App Summary
                       Pss(KB)
                        ------
           Java Heap:     3652
         Native Heap:     3396
                Code:     1956
               Stack:       48
            Graphics:    35124
       Private Other:      828
              System:     4358 
               TOTAL:    49362       TOTAL SWAP PSS:      162

 Objects
               Views:       22         ViewRootImpl:        2
         AppContexts:        3           Activities:        1
              Assets:        3        AssetManagers:        4
       Local Binders:       15        Proxy Binders:       21
       Parcel memory:        3         Parcel count:       13
    Death Recipients:        2      OpenSSL Sockets:        0
            WebViews:        0 

 Dalvik
         isLargeHeap:    false 

 SQL
         MEMORY_USED:        0
  PAGECACHE_OVERFLOW:        0          MALLOC_SIZE:        0
复制代码

2.1.3 adb shell cat /proc/meminfo

读取/proc/meminfo文件,可以获取系统整体内存使用情况:

>adb shell cat /proc/meminfo
MemTotal:        5826364 kB   //内存总大小
MemFree:           85532 kB   //空闲内存总大小
MemAvailable:    3540368 kB
Buffers:          127840 kB
Cached:          3373548 kB
SwapCached:        10952 kB   
Active:          2928196 kB
Inactive:        1346956 kB
Active(anon):     427512 kB
Inactive(anon):   432012 kB
Active(file):    2500684 kB
Inactive(file):   914944 kB
Unevictable:       81280 kB
Mlocked:           81280 kB
SwapTotal:       2097148 kB   //交换空间总大小
SwapFree:        1449580 kB   //交换空间空闲大小
复制代码

2.1.4 procrank

procrank命令可以获取系统中所有进程的VSS、RSS、PSS、USS的大小:

>adb shell procrank
PID Vss      Rss     Pss     Uss    cmdline
380 2195880K 210712K 111133K 67400K system_server
146 1561656K 63080  47628K  42036K zygote
868 1587984K 69500K  25414K  18480K com.android.launcher
145 2122596K 73552K  23428K  10972K zygote64
复制代码

2.2 Android Studio Profiler

Android studio自带的profiler工具可以选择MEMORY查看当前内存使用情况,如下所示: memory-profiler-callouts_2x.png 其中列出了所选进程的内存使用情况,这里的java heap、native heap都是指虚拟内存大小: memory-profiler-counts_2x.png

2.3 代码获取

2.3.1 手机总内存情况MemoryInfo

MemoryInfo内包含的内存信息如下:

public static class MemoryInfo implements Parcelable {

    public long availMem;
    public long totalMem;
    public long threshold;
    public boolean lowMemory;
}
复制代码

获取MemoryInfo的方式如下:

// Activity中已经实现了获取activityManager,自定义类中通过这种方式获取ActivityManager:
ActivityManager am = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
ActivityManager.MemoryInfo memoryInfo = new ActivityManager.MemoryInfo();
am.getMemoryInfo(memoryInfo);

Log.v(TAG,"手机总内存:" + memoryInfo.totalMem);
Log.v(TAG,"手机当前可用物理内存:" + memoryInfo.availMem);
Log.v(TAG,"Android系统认为低内存状态的阈值:" + memoryInfo.threshold);
复制代码

2.3.2 读取/proc/meminfo文件

读取/proc/meminfo文件,同样可获取系统总内存情况,可获取的信息见2.1.3;代码如下:

public static long getRamSwapFree() {
    // // 系统内存信息文件
    String str1 = "/proc/meminfo"; 
    String str2;
    String[] arrayOfString;
    long swapFree = 0;
    InputStreamReader localFileReader = null;
    BufferedReader localBufferedReader = null;
    try {
        localFileReader = new InputStreamReader(new FileInputStream(str1), Charset.forName("utf-8"));
        localBufferedReader = new BufferedReader(localFileReader, 8192);
        while ((str2 = localBufferedReader.readLine()) != null) {
            arrayOfString = str2.split("\s+");
            if (arrayOfString.length >= 2) {
                String memType = arrayOfString[0];
                // 下面是个例子,类似地可获取其他更多信息
                if (TextUtils.equals(arrayOfString[0], "SwapFree:")) {
                    swapFree = Integer.parseInt(arrayOfString[1]);
                }
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        if (null != localBufferedReader) {
            try {
                localBufferedReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        if (null != localFileReader) {
            try {
                localFileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    return swapFree / (1024);
}
复制代码

2.3.3 获取当前进程PSS物理内存

Debug.MemoryInfo memoryInfo = new Debug.MemoryInfo();
Debug.getMemoryInfo(memoryInfo);
Log.v(TAG,"总PSS:"+memoryInfo.getTotalPss());
Log.v(TAG,"Java PSS:" + memoryInfo.dalvikPss);
Log.v(TAG,"Native PSS:" + memoryInfo.nativePss);
Log.v(TAG,"总RSS:"+memoryInfo.getTotalRss());

// 安卓6.0以上还可以使用如下方式:
Log.v(TAG,"安卓6.0以上,total-pss:"+memoryInfo.getMemoryStat("summary.total-pss"));
Log.v(TAG,"安卓6.0以上,java-heap:"+memoryInfo.getMemoryStat("summary.java-heap"));
Log.v(TAG,"安卓6.0以上,native-heap:"+memoryInfo.getMemoryStat("summary.native-heap"));
Log.v(TAG,"安卓6.0以上,code:"+memoryInfo.getMemoryStat("summary.code"));
Log.v(TAG,"安卓6.0以上,graphics:"+memoryInfo.getMemoryStat("summary.graphics"));
复制代码

2.3.4 获取当前进程VSS虚拟内存

(1)获取java堆VSS

long javaMaxHeapSize = Runtime.getRuntime().maxMemory();
long javaTotalHeapSize = Runtime.getRuntime().totalMemory();
long javaFreeHeapSize = Runtime.getRuntime().freeMemory();
Log.v(TAG,"java堆最大内存大小:"+javaMaxHeapSize);
Log.v(TAG,"当前java堆内存大小:"+javaTotalHeapSize);
Log.v(TAG,"当前java堆空闲内存大小:"+javaFreeHeapSize);
复制代码
  • maxMemory是虚拟机启动过程中就确定的,默认值根据RAM大小设定(192M (2G RAM)、192M (4G RAM)、256M (6G RAM),但是也和具体的机型配置相关),如果开启了largeHeap就是512M)。
  • totalMemory是当前堆大小,最多能增加到maxMemory。

(2)获取native堆VSS

long nativeHeap = Debug.getNativeHeapSize();
long nativeAllocHeap = Debug.getNativeHeapAllocatedSize();
long nativeFreeSize = Debug.getNativeHeapFreeSize();
Log.v(TAG,"当前native堆内存大小:"+nativeHeap);
Log.v(TAG,"当前native堆已分配内存大小:"+nativeAllocHeap);
Log.v(TAG,"当前native堆空闲内存大小:"+nativeFreeSize);
复制代码
  • native heap的增长并不受dalvik vm heapsize的限制,只要虚拟内存有剩余空间,应用程序可以一直在native heap上申请空间,见参考

ps:native层虚拟内存或物理内存不足时,都会发生OOM。

三、低内存状态

3.1 LMK进程

很多时候,kswapd 不能为系统释放足够的内存。在这种情况下,系统会使用 onTrimMemory() 通知应用内存不足,应该减少其分配量。如果这还不够,内核会开始终止进程以释放内存。它会使用低内存终止守护进程 (LMK) 来执行此操作。
LMK 使用一个名为 oom_adj_score 的“内存不足”分值来确定正在运行的进程的优先级,以此决定要终止的进程。最高得分的进程最先被终止。后台应用最先被终止,系统进程最后被终止。下表列出了从高到低的 LMK 评分类别。评分最高的类别,即第一行中的项目将最先被终止(设备制造商可以更改 LMK 的行为。): lmk-process-order.svg
以下是上表中各种类别的说明:

  • 后台应用:之前运行过且当前不处于活动状态的应用。LMK 将首先从具有最高 oom_adj_score 的应用开始终止后台应用。
  • 上一个应用:最近用过的后台应用。上一个应用比后台应用具有更高的优先级(得分更低),因为相比某个后台应用,用户更有可能切换到上一个应用。
  • 主屏幕应用:这是启动器应用。终止该应用会使壁纸消失。
  • 服务:服务由应用启动,可能包括同步或上传到云端。
  • 可觉察的应用:用户可通过某种方式察觉到的非前台应用,例如运行一个显示小界面的搜索进程或听音乐。
  • 前台应用:当前正在使用的应用。终止前台应用看起来就像是应用崩溃了,可能会向用户提示设备出了问题。
  • 持久性(服务):这些是设备的核心服务,例如电话和 WLAN。
  • 系统:系统进程。这些进程被终止后,手机可能看起来即将重新启动。
  • 原生:系统使用的极低级别的进程(例如,kswapd)。

3.2 onTrimMemory()

上面介绍过,当内存不足时,系统会回调onTrimMemory()来通知应用程序内存不足,onTrimMemory()的定义如下:

public interface ComponentCallbacks2 extends ComponentCallbacks {
    void onTrimMemory(@TrimMemoryLevel int level);
}
复制代码

对于Application、Activity、Fragment、Service、ContentProvider,源码中已经继承了ComponentCallbacks2接口,如果开发者需要自定义onTrimMemory的更多行为(例如收到内存不足回调时,进行一些内存释放工作),直接重写父类的方法即可;
如果开发者需要在自定义的类中接收ComponentCallbacks2系统回调,可按如下方式注册:

public class ComponentCallbacksDemo implements ComponentCallbacks2{
    
    public ComponentCallbacksDemo() {
        // 注册ComponentCallbacks回调
        getApplicationContext().registerComponentCallbacks(this);
    }
    
    @Override
    public void onTrimMemory(int level) {
        if (level >= TRIM_MEMORY_UI_HIDDEN) {
            // todo do some free memory work
        }
    }
    
    @Override
    public void onConfigurationChanged(@NonNull Configuration newConfig) {}
    
    @Override
    public void onLowMemory() {}
}
复制代码

当onTrimMemory(int level)回调时,level表示内存等级,level有以下几种类型:

/**
 * Level for {@link #onTrimMemory(int)}: the process is nearing the end
 * of the background LRU list, and if more memory isn't found soon it will
 * be killed.
 */
static final int TRIM_MEMORY_COMPLETE = 80;

/**
 * Level for {@link #onTrimMemory(int)}: the process is around the middle
 * of the background LRU list; freeing memory can help the system keep
 * other processes running later in the list for better overall performance.
 */
static final int TRIM_MEMORY_MODERATE = 60;

/**
 * Level for {@link #onTrimMemory(int)}: the process has gone on to the
 * LRU list.  This is a good opportunity to clean up resources that can
 * efficiently and quickly be re-built if the user returns to the app.
 */
static final int TRIM_MEMORY_BACKGROUND = 40;

/**
 * Level for {@link #onTrimMemory(int)}: the process had been showing
 * a user interface, and is no longer doing so.  Large allocations with
 * the UI should be released at this point to allow memory to be better
 * managed.
 */
static final int TRIM_MEMORY_UI_HIDDEN = 20;

/**
 * Level for {@link #onTrimMemory(int)}: the process is not an expendable
 * background process, but the device is running extremely low on memory
 * and is about to not be able to keep any background processes running.
 * Your running process should free up as many non-critical resources as it
 * can to allow that memory to be used elsewhere.  The next thing that
 * will happen after this is {@link #onLowMemory()} called to report that
 * nothing at all can be kept in the background, a situation that can start
 * to notably impact the user.
 */
static final int TRIM_MEMORY_RUNNING_CRITICAL = 15;

/**
 * Level for {@link #onTrimMemory(int)}: the process is not an expendable
 * background process, but the device is running low on memory.
 * Your running process should free up unneeded resources to allow that
 * memory to be used elsewhere.
 */
static final int TRIM_MEMORY_RUNNING_LOW = 10;

/**
 * Level for {@link #onTrimMemory(int)}: the process is not an expendable
 * background process, but the device is running moderately low on memory.
 * Your running process may want to release some unneeded resources for
 * use elsewhere.
 */
static final int TRIM_MEMORY_RUNNING_MODERATE = 5;
复制代码

3.3 onLowMemory()

onTrimMemory是API 14及以上可使用,对于低系统可使用onLowMemory(),其等同于ComponentCallbacks2的当onTrimMemory(TRIM_MEMORY_COMPLETE}回调,对于高系统建议实现nTrimMemory()即可。

public interface ComponentCallbacks {
    void onConfigurationChanged(@NonNull Configuration newConfig);
    void onLowMemory();
}
复制代码
分类:
Android
标签:
分类:
Android
标签: