Como obter o uso de memória atual no Android?

Usei / proc / meminfo e analisei a resposta do comando. No entanto, o resultado mostra que:

MemTotal: 94348 kB MemFree: 5784 kB

significa. mostra que há apenas 5 MB de memória livre. É possível com o Android móvel? Há apenas 5-6 aplicativos instalados no meu celular e nenhuma outra tarefa está em execução. mas ainda assim este comando mostra que há muito pouca memória livre.

Alguém pode esclarecer isso? ou existe alguma outra maneira de obter o uso de memória no Android?

CUIDADO: Esta resposta mede o uso / disponibilidade da memória do DISPOSITIVO. NÃO é isso que está disponível para seu aplicativo. Para medir o que seu APP está fazendo e tem permissão para fazer, use a resposta do desenvolvedor do Android .

Documentos Android - ActivityManager.MemoryInfo

1. comando parse / proc / meminfo. Você pode encontrar o código de referência aqui: Obtenha o uso da memória no Android

2. use o código abaixo e obtenha RAM atual:

   MemoryInfo mi = new MemoryInfo();
   ActivityManager activityManager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
   activityManager.getMemoryInfo(mi);
   double availableMegs = mi.availMem / 0x100000L;
   
   //Percentage can be calculated for API 16+
   double percentAvail = mi.availMem / (double)mi.totalMem * 100.0;

Explicação do número 0x100000L

1024 bytes      == 1 Kibibyte 
1024 Kibibyte   == 1 Mebibyte

1024 * 1024     == 1048576
1048576         == 0x100000

É bastante óbvio que o número é usado para converter de bytes em mebibyte

PS: precisamos calcular a memória total apenas uma vez. então chame o ponto 1 apenas uma vez em seu código e depois, você pode chamar o código do ponto 2 repetidamente.

Depende da sua definição de qual consulta de memória você deseja obter.

Normalmente, você gostaria de saber o status da memória heap, uma vez que se ela usar muita memória, você obtém OOM e falha o aplicativo.

Para isso, você pode verificar os próximos valores:

final Runtime runtime = Runtime.getRuntime();
final long usedMemInMB=(runtime.totalMemory() - runtime.freeMemory()) / 1048576L;
final long maxHeapSizeInMB=runtime.maxMemory() / 1048576L;
final long availHeapSizeInMB = maxHeapSizeInMB - usedMemInMB;

Quanto mais a variável "usedMemInMB" se aproxima de "maxHeapSizeInMB", quanto mais perto availHeapSizeInMBchega de zero, mais perto você obtém OOM. (Devido à fragmentação da memória, você pode obter OOM ANTES de chegar a zero.)

Isso também é o que mostra a ferramenta DDMS de uso de memória.

Alternativamente, existe o uso real de RAM, que é quanto todo o sistema usa - veja a resposta aceita para calcular isso.

Atualização: como o Android O faz seu aplicativo também usar a RAM nativa (pelo menos para armazenamento de bitmaps, que geralmente é o principal motivo para o uso excessivo de memória), e não apenas o heap, as coisas mudaram e você obtém menos OOM (porque o heap não contém mais bitmaps, verifique aqui ), mas você ainda deve ficar de olho no uso da memória se suspeitar que há vazamentos de memória. No Android O, se você tiver vazamentos de memória que deveriam ter causado OOM em versões mais antigas, parece que ele irá travar sem que você consiga detectá-lo. Veja como verificar o uso de memória:

val nativeHeapSize = Debug.getNativeHeapSize()
val nativeHeapFreeSize = Debug.getNativeHeapFreeSize()
val usedMemInBytes = nativeHeapSize - nativeHeapFreeSize
val usedMemInPercentage = usedMemInBytes * 100 / nativeHeapSize

Mas acredito que seja melhor usar o profiler do IDE, que mostra os dados em tempo real, usando um gráfico.

Portanto, a boa notícia no Android O é que é muito mais difícil travar devido ao OOM de armazenar muitos bitmaps grandes, mas a má notícia é que não acho que seja possível detectar tal caso durante o tempo de execução.

EDIT: parece Debug.getNativeHeapSize()mudar com o tempo, pois mostra a memória máxima total para seu aplicativo. Portanto, essas funções são usadas apenas para o criador de perfil, para mostrar o quanto seu aplicativo está usando.

Se você deseja obter o total real e a RAM nativa disponível, use:

val memoryInfo = ActivityManager.MemoryInfo()
(getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager).getMemoryInfo(memoryInfo)
val nativeHeapSize = memoryInfo.totalMem
val nativeHeapFreeSize = memoryInfo.availMem
val usedMemInBytes = nativeHeapSize - nativeHeapFreeSize
val usedMemInPercentage = usedMemInBytes * 100 / nativeHeapSize
Log.d("AppLog", "total:${Formatter.formatFileSize(this, nativeHeapSize)} " +
        "free:${Formatter.formatFileSize(this, nativeHeapFreeSize)} " +
        "used:${Formatter.formatFileSize(this, usedMemInBytes)} ($usedMemInPercentage%)")

Esta é uma maneira de calcular o uso de memória do aplicativo em execução :

public static long getUsedMemorySize() {

    long freeSize = 0L;
    long totalSize = 0L;
    long usedSize = -1L;
    try {
        Runtime info = Runtime.getRuntime();
        freeSize = info.freeMemory();
        totalSize = info.totalMemory();
        usedSize = totalSize - freeSize;
    } catch (Exception e) {
        e.printStackTrace();
    }
    return usedSize;

}

Outra forma (atualmente mostrando 25 MB livres no meu G1):

MemoryInfo mi = new MemoryInfo();
ActivityManager activityManager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
activityManager.getMemoryInfo(mi);
long availableMegs = mi.availMem / 1048576L;

A filosofia de gerenciamento de memória do Linux é "Memória livre é memória desperdiçada".

Presumo que as próximas duas linhas mostrarão quanta memória há em "Buffers" e quanta está em "Cache". Embora haja uma diferença entre os dois (por favor, não pergunte qual é essa diferença :) ambos somam aproximadamente a quantidade de memória usada para armazenar dados e metadados do arquivo em cache.

Um guia muito mais útil para liberar memória em um sistema Linux é o free(1)comando; na minha área de trabalho, ele relata informações como esta:

$ free -m
             total de buffers compartilhados gratuitos usados ​​em cache
Mem: 5980 1055 4924 0 91 374
- / + buffers / cache: 589 5391
Troca: 6347 0 6347

A linha +/- buffers / cache: é a linha mágica, ela relata que eu realmente tenho cerca de 589 megs de memória de processo ativamente exigida e cerca de 5391 megs de memória 'livre', no sentido de que os 91 + 374 megabytes de buffers / memória em cache podem ser descartados se a memória pudesse ser usada de forma mais lucrativa em outro lugar.

(Minha máquina está ligada há cerca de três horas, fazendo quase nada além de stackoverflow, e é por isso que tenho tanta memória livre.)

Se o Android não for fornecido free(1), você mesmo pode fazer as contas com o /proc/meminfoarquivo; Eu apenas gosto do free(1)formato de saída. :)

Refiro-me a alguns escritos.

referência:

• http://www.hanbit.co.kr/network/view.html?bi_id=1313
• Como obter o tamanho total da RAM de um dispositivo?

Este método getMemorySize () é retornado como MemorySize com tamanho de memória total e livre.
Eu não acredito neste código perfeitamente.
Este código está sendo testado no LG G3 cat.6 (v5.0.1)

    private MemorySize getMemorySize() {
        final Pattern PATTERN = Pattern.compile("([a-zA-Z]+):\\s*(\\d+)");

        MemorySize result = new MemorySize();
        String line;
        try {
            RandomAccessFile reader = new RandomAccessFile("/proc/meminfo", "r");
            while ((line = reader.readLine()) != null) {
                Matcher m = PATTERN.matcher(line);
                if (m.find()) {
                    String name = m.group(1);
                    String size = m.group(2);

                    if (name.equalsIgnoreCase("MemTotal")) {
                        result.total = Long.parseLong(size);
                    } else if (name.equalsIgnoreCase("MemFree") || name.equalsIgnoreCase("Buffers") ||
                            name.equalsIgnoreCase("Cached") || name.equalsIgnoreCase("SwapFree")) {
                        result.free += Long.parseLong(size);
                    }
                }
            }
            reader.close();

            result.total *= 1024;
            result.free *= 1024;
        } catch (IOException e) {
            e.printStackTrace();
        }

        return result;
    }

    private static class MemorySize {
        public long total = 0;
        public long free = 0;
    }

Eu sei que Pattern.compile () tem um custo caro, então você pode mover seu código para o membro da classe.

Eu olhei para Android Source Tree.

Dentro de com.android.server.am. ActivityManagerService.java (serviço interno exposto por android.app. ActivityManager ).

public void getMemoryInfo(ActivityManager.MemoryInfo outInfo) {
    final long homeAppMem = mProcessList.getMemLevel(ProcessList.HOME_APP_ADJ);
    final long hiddenAppMem = mProcessList.getMemLevel(ProcessList.HIDDEN_APP_MIN_ADJ);
    outInfo.availMem = Process.getFreeMemory();
    outInfo.totalMem = Process.getTotalMemory();
    outInfo.threshold = homeAppMem;
    outInfo.lowMemory = outInfo.availMem < (homeAppMem + ((hiddenAppMem-homeAppMem)/2));
    outInfo.hiddenAppThreshold = hiddenAppMem;
    outInfo.secondaryServerThreshold = mProcessList.getMemLevel(
            ProcessList.SERVICE_ADJ);
    outInfo.visibleAppThreshold = mProcessList.getMemLevel(
            ProcessList.VISIBLE_APP_ADJ);
    outInfo.foregroundAppThreshold = mProcessList.getMemLevel(
            ProcessList.FOREGROUND_APP_ADJ);
}

Dentro de android.os. Process.java

/** @hide */
public static final native long getFreeMemory();

/** @hide */
public static final native long getTotalMemory();

Ele chama o método JNI de android_util_Process.cpp

Conclusão

MemoryInfo.availMem = MemFree + Armazenado em cache em / proc / meminfo.

Notas

Memória total é adicionada no nível 16 da API.

você também pode usar a ferramenta DDMS que faz parte do próprio SDK do Android. ele ajuda a obter alocações de memória de código java e código c / c ++ nativo também.

public static boolean isAppInLowMemory(Context context) {
    ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
    ActivityManager.MemoryInfo memoryInfo = new ActivityManager.MemoryInfo();
    activityManager.getMemoryInfo(memoryInfo);

    return memoryInfo.lowMemory;
}

final long usedMemInMB=(runtime.totalMemory() - runtime.freeMemory()) / 1048576L;
final long maxHeapSizeInMB=runtime.maxMemory() / 1048576L;
final long availHeapSizeInMB = maxHeapSizeInMB - usedMemInMB;

É um código estranho. Ele retorna MaxMemory - (totalMemory - freeMemory). Se freeMemory for igual a 0, o código retornará MaxMemory - totalMemory, portanto, pode ser maior ou igual a 0. Por que freeMemory não foi usado?

Esta é outra maneira de visualizar o uso de memória do seu aplicativo:

adb shell dumpsys meminfo <com.package.name> -d

Saída de amostra:

Applications Memory Usage (kB):
Uptime: 2896577 Realtime: 2896577

** MEMINFO in pid 2094 [com.package.name] **
                   Pss  Private  Private  Swapped     Heap     Heap     Heap
                 Total    Dirty    Clean    Dirty     Size    Alloc     Free
                ------   ------   ------   ------   ------   ------   ------
  Native Heap     3472     3444        0        0     5348     4605      102
  Dalvik Heap     2349     2188        0        0     4640     4486      154
 Dalvik Other     1560     1392        0        0
        Stack      772      772        0        0
    Other dev        4        0        4        0
     .so mmap     2749     1040     1220        0
    .jar mmap        1        0        0        0
    .apk mmap      218        0       32        0
    .ttf mmap       38        0        4        0
    .dex mmap     3161       80     2564        0
   Other mmap        9        4        0        0
      Unknown       76       76        0        0
        TOTAL    14409     8996     3824        0     9988     9091      256

 Objects
               Views:       30         ViewRootImpl:        2
         AppContexts:        4           Activities:        2
              Assets:        2        AssetManagers:        2
       Local Binders:       17        Proxy Binders:       21
    Death Recipients:        7
     OpenSSL Sockets:        0

 SQL
         MEMORY_USED:        0
  PAGECACHE_OVERFLOW:        0          MALLOC_SIZE:        0

Para uso geral de memória:

adb shell dumpsys meminfo

https://developer.android.com/studio/command-line/dumpsys#meminfo