Ispeziona la memoria utilizzata dalla tua app con Memory Profiler

Memory Profiler è un componente della Android Profiler ti aiuta a identificare le fughe di memoria e il tasso di abbandono della memoria che possono causare stuttering, si blocca e persino l'app ha un arresto anomalo. Mostra un grafico in tempo reale della memoria della tua app. e consente di acquisire un dump dell'heap, forzare le garbage collection e monitorare alla distribuzione della memoria.

Per aprire Memory Profiler, segui questi passaggi:

1. Fai clic su Visualizza > Finestre degli strumenti > Profiler (puoi anche fare clic su Profilo) nella barra degli strumenti).
2. Seleziona il dispositivo e il processo dell'app che vuoi profilare da Android Barra degli strumenti di Profiler. Se hai collegato un dispositivo tramite USB, ma non lo vedi elencati, assicurati di avere attivato il debug USB.
3. Fai clic in un punto qualsiasi della sequenza temporale MEMORY per aprire Memory Profiler.

In alternativa, puoi controllare la memoria dell'app dalla riga di comando con dumpsys e anche vedi gli eventi di GC in logcat.

Perché dovresti profilare la memoria dell'app

Android offre una ambiente di memoria gestito, quando stabilisce che la tua app non usa più alcuni oggetti, il garbage collector e rilascia nuovamente la memoria inutilizzata nell'heap. In che modo Android trova memoria inutilizzata viene costantemente migliorata, ma a un certo punto su tutte le versioni successive, il sistema deve mettere in pausa brevemente il codice. La maggior parte delle volte le pause sono impercettibili. Tuttavia, se la tua app alloca la memoria più velocemente di quella del sistema possono raccoglierli, l'app potrebbe subire ritardi mentre il raccoglitore libera abbastanza per soddisfare le tue allocazioni. Il ritardo potrebbe causare l'esclusione dell'app e causano rallentamenti visibili.

Anche se la tua app non presenta rallentamenti, se perde memoria, può mantenere quel ricordo anche quando è in background. Questo comportamento può rallentare il resto delle prestazioni della memoria del sistema forzando la garbage collection non necessaria eventi. Alla fine, il sistema sarà costretto a terminare il processo dell'app per recuperare la memoria. In seguito, quando l'utente torna all'app, questa deve riavviarsi completamente.

Per evitare questi problemi, devi usare Memory Profiler per eseguire le seguenti:

• Cerca nella sequenza temporale eventuali pattern di allocazione della memoria indesiderati che potrebbero problemi di prestazioni.
• Esegui il dump dell'heap Java per vedere quali oggetti stanno utilizzando la memoria in un determinato momento nel tempo. Diversi dump dell'heap in un periodo di tempo prolungato possono aiutare a identificare perdite di memoria.
• Registra le allocazioni di memoria durante l'interazione utente normale e estrema per identificare esattamente il punto in cui il codice alloca troppi oggetti per un breve periodo di tempo o allocare oggetti che si sono persi.

Per informazioni sulle pratiche di programmazione che possono ridurre la memoria della tua app consulta l'articolo Gestire la memoria dell'app.

Panoramica di Memory Profiler

Quando apri per la prima volta Memory Profiler, vedrai una sequenza temporale dettagliata utilizzo della memoria dell'app e accesso a strumenti per forzare la garbage collection e acquisire un heap eseguire il dump e registrare le allocazioni della memoria.

Figura 1. Memory Profiler

Come indicato nella figura 1, la visualizzazione predefinita per Memory Profiler include seguenti:

1. Un pulsante per forzare un evento di garbage collection.

2. Un pulsante per acquisire un dump dell'heap.

   Nota: un pulsante per registrare il ricordo. di allocazione viene visualizzato a destra del pulsante di dump dell'heap solo quando connesso a un dispositivo con Android 7.1 (livello API 25) o versioni precedenti.

3. Un menu a discesa per specificare la frequenza con cui il profiler acquisisce la memoria allocazioni. La selezione dell'opzione appropriata può aiutarti migliorare le prestazioni dell'app durante la profilazione.
4. Pulsanti per aumentare/ridurre lo zoom della sequenza temporale.
5. Un pulsante per passare ai dati della memoria live.
6. La sequenza temporale degli eventi, che mostra gli stati dell'attività, gli eventi di input dell'utente e di rotazione dello schermo.
7. La sequenza temporale dell'utilizzo della memoria, che include quanto segue:
   • Un grafico in pila della quantità di memoria utilizzata da ogni categoria di memoria. come indicato dall'asse y a sinistra e dal tasto del colore in alto.
   • Una linea tratteggiata indica il numero di oggetti allocati, come indicato per l'asse y a destra.
   • Un'icona per ogni evento di garbage collection.

Tuttavia, se utilizzi un dispositivo con Android 7.1 o versioni precedenti, non tutti i dati di profilazione sono visibili per impostazione predefinita. Se viene visualizzato il messaggio "Avanzate la profilazione non è disponibile per il processo selezionato", è necessario attivare la profilazione avanzata per visualizzare le seguenti informazioni:

• Cronologia degli eventi
• Numero di oggetti allocati
• Eventi di garbage collection

Su Android 8.0 e versioni successive, la profilazione avanzata è sempre abilitata per il debug app.

Come viene conteggiata la memoria

I numeri visualizzati nella parte superiore di Memory Profiler (Figura 2) si basano su tutte le pagine della memoria privata di cui la tua app ha eseguito il commit, in base alle Sistema Android. Questo conteggio non include le pagine condivise con il sistema o altre app.

Figura 2. La legenda del conteggio delle memoria in alto di Memory Profiler

Le categorie incluse nel conteggio della memoria sono le seguenti:

• Java: memoria dagli oggetti allocati da codice Java o Kotlin.

• Nativa: memoria degli oggetti allocati dal codice C o C++.

  Anche se non utilizzi C++ nella tua app, potresti vedere un po' di memoria nativa usata qui perché il framework Android usa la memoria nativa per gestire varie attività per tuo conto, ad esempio la gestione degli asset immagine anche se il codice che hai scritto è in Java o Kotlin.

• Elementi grafici: memoria utilizzata per le code del buffer grafico per visualizzare i pixel su sullo schermo, incluse superfici GL, texture GL e così via. Tieni presente che è la memoria condivisa con la CPU, non la memoria GPU dedicata).

• Stack: memoria utilizzata dagli stack nativi e Java nell'app. Questo di solito è relativo al numero di thread in esecuzione nell'app.

• Codice: memoria utilizzata dall'app per codice e risorse, ad esempio dex bytecode, dex code ottimizzato o compilato, librerie .so e caratteri.

• Altro: memoria utilizzata dall'app che il sistema non è sicuro di come eseguire classificare.

• Allocati: il numero di oggetti Java/Kotlin allocati dalla tua app. Non vengono conteggiati gli oggetti allocati in C o C++.

  Se connesso a un dispositivo con Android 7.1 e versioni precedenti, questa allocazione inizia solo nel momento in cui il Memory Profiler si è connesso al tuo in esecuzione. Pertanto, gli oggetti allocati prima di iniziare la profilazione non vengono preso in considerazione. Tuttavia, Android 8.0 e versioni successive includono un di profilazione che tiene traccia di tutte le allocazioni, in modo che questo numero rappresenta il numero totale di oggetti Java in sospeso nella tua app Android 8.0 e versioni successive.

Rispetto al numero di memoria del precedente strumento Android Monitor, la nuova Memory Profiler registra la memoria in modo diverso, quindi potrebbe sembrare che tu la quantità di memoria utilizzata è ora maggiore. Memory Profiler monitora alcune categorie aggiuntive che aumentano il totale, ma se ti interessa solo la memoria heap Java, il comando "Java" dovrebbe essere simile al valore dello strumento precedente. Anche se il numero Java probabilmente non corrisponde esattamente a quello che vedi in Android Monitorate, il nuovo numero include tutte le pagine di memoria fisica che sono state allocato all'heap Java della tua app perché è stato creato con fork da Zygote. Quindi questo fornisce una rappresentazione accurata della quantità di memoria fisica della tua app che sta usando.

Visualizza allocazioni della memoria

Le allocazioni della memoria mostrano in che modo ciascun oggetto Java e riferimento JNI nel tuo è stata allocata. Nello specifico, Memory Profiler può mostrarti sulle allocazioni degli oggetti:

• Quali tipi di oggetti sono stati allocati e quanto spazio utilizzano.
• L'analisi dello stack di ogni allocazione, incluso il thread.
• La posizione nell'offerta degli oggetti (solo quando viene utilizzato un dispositivo con Android 8.0). o superiore).

Per registrare le allocazioni Java e Kotlin, seleziona Registrare le allocazioni Java / Kotlin, quindi seleziona Registra. Se il dispositivo utilizza Android 8 o versioni successive, L'UI di Memory Profiler passa a una schermata separata che mostra registrazione in tempo reale. Puoi interagire con la mini sequenza temporale sopra la registrazione (ad esempio, per modificare l'intervallo di selezione). Per completare la registrazione: Seleziona Interrompi .

Su Android 7.1 e versioni precedenti, il profiler della memoria utilizza l'allocazione precedente registrazione, che mostra la registrazione sulla sequenza temporale fino a quando Interrompi.

Dopo aver selezionato un'area della sequenza temporale (o quando termini una registrazione) con un dispositivo con Android 7.1 o versioni precedenti), l'elenco delle gli oggetti visualizzati, raggruppati per nome di classe e ordinati per conteggio heap.

Per esaminare il record di allocazione:

1. Sfoglia l'elenco per trovare oggetti con conteggi di heap insolitamente elevati. che potrebbero essere divulgate. Per trovare i corsi noti, fai clic su Nome corso l'intestazione della colonna per ordinare alfabeticamente. Quindi, fai clic sul nome di un corso. La Il riquadro Vista istanze appare sulla destra e mostra ogni istanza della come mostrato nella figura 3.
   • In alternativa, puoi individuare rapidamente gli oggetti facendo clic su Filtra , oppure premendo Ctrl+F (Comando+F su Mac) e inserendo una classe o un pacchetto nel campo di ricerca. Se selezioni questa opzione, puoi anche cercare in base al nome del metodo Ordina in base all'area di chiamata dal menu a discesa. Se vuoi utilizzare la modalità , seleziona la casella accanto a regex. Seleziona la casella accanto a Maiuscole/minuscole se la query di ricerca è sensibile alle maiuscole.
2. Nel riquadro Vista istanza, fai clic su un'istanza. La scheda Stack di chiamate viene visualizzato sotto, che mostra dove è stata allocata l'istanza e in quale thread.
3. Nella scheda Stack di chiamate, fai clic con il tasto destro del mouse su una riga e scegli Passa al codice sorgente per aprire il codice nell'editor.

Figura 3. Dettagli su ogni oggetto allocato nella Vista dell'istanza a destra

Puoi usare i due menu sopra l'elenco degli oggetti allocati per scegliere quali e come organizzare i dati.

Dal menu a sinistra, scegli quale heap ispezionare:

• heap predefinito: quando il sistema non specifica alcun heap.
• heap immagine: l'immagine di avvio del sistema, contenente le classi è precaricato durante l'avvio. È garantito che le allocazioni in questo punto non vengano mai spostate spariscono.
• heap zygote: l'heap di copia alla scrittura da cui viene generato il fork di un processo dell'app nel sistema Android.
• heap di app: l'heap principale su cui l'app alloca la memoria.
• heap JNI. L'heap che mostra il punto in cui Java Native Interface (JNI) vengono allocati e rilasciati.

Dal menu a destra, scegli come organizzare le allocazioni:

• Ordina per classe: raggruppa tutte le allocazioni in base al nome della classe. Questo è per impostazione predefinita.
• Ordina per pacchetto: raggruppa tutte le allocazioni in base al nome del pacchetto.
• Disponi per calltack: raggruppa tutte le allocazioni nelle corrispondenti e lo stack di chiamate.

Migliora le prestazioni dell'app durante la profilazione

Per migliorare le prestazioni dell'app durante la profilazione, il profiler di memoria campiona la memoria allocata periodicamente per impostazione predefinita. Durante i test su dispositivi che eseguono l'API livello 26 o superiore, puoi modificare questo comportamento utilizzando il menu a discesa Monitoraggio allocazione. Le opzioni disponibili sono che segue:

• Completa: acquisisce tutte le allocazioni di oggetti in memoria. Questa è l'impostazione predefinita in Android Studio 3.2 e versioni precedenti. Se hai un'app che molti oggetti, potresti osservare rallentamenti visibili con durante la profilazione.
• Campionati: campiona le allocazioni degli oggetti in memoria a intervalli regolari. Questo è l'opzione predefinita e ha un impatto minore sulle prestazioni dell'app, mentre la profilazione. Le app che allocano molti oggetti in un breve arco di tempo possono mostrare comunque rallentamenti visibili.
• Off: interrompe il monitoraggio dell'allocazione della memoria dell'app.

Visualizza i riferimenti JNI globali

Java Native Interface (JNI) è un framework che consente di utilizzare codice Java e per chiamarsi reciprocamente.

I riferimenti JNI sono gestiti manualmente dal codice nativo, quindi è possibile Gli oggetti Java utilizzati dal codice nativo devono essere mantenuti attivi per troppo tempo. Alcuni oggetti su l'heap Java potrebbe diventare irraggiungibile se un riferimento JNI viene ignorato senza essere stati eliminati esplicitamente. Inoltre, è possibile esaurire le risorse limite di riferimento.

Per risolvere questi problemi, usa la visualizzazione dell'heap JNI in Memory Profiler per sfoglia tutti i riferimenti JNI globali e filtrali per tipi Java e chiamata nativa simili. Con queste informazioni, puoi sapere quando e dove a livello globale JNI fa riferimento vengono creati ed eliminati.

Mentre l'app è in esecuzione, seleziona una parte della sequenza temporale che vuoi esamina e seleziona heap JNI dal menu a discesa sopra l'elenco dei corsi. Puoi quindi ispezionare gli oggetti nell'heap come faresti normalmente e fare doppio clic nella scheda Stack di chiamate di allocazione per vedere dove sono i riferimenti JNI allocati e rilasciati nel codice, come mostrato nella figura 4.

Figura 4. Visualizzazione dei riferimenti JNI globali

Per ispezionare le allocazioni della memoria per il codice JNI dell'app, devi eseguire il deployment dell'app su un dispositivo con Android 8.0 o versioni successive.

Per ulteriori informazioni su JNI, consulta i suggerimenti per JNI.

Profiler di memoria nativo

Android Studio Memory Profiler include un Profiler di memoria nativo per le app distribuite su dispositivi fisici e virtuali con Android 10 e versioni successive.

Native Memory Profiler traccia le allocazioni/le località dei deal degli oggetti per un periodo di tempo specifico e fornisce le seguenti informazioni:

• Allocazioni: un conteggio degli oggetti allocati tramite malloc() o new durante il periodo di tempo selezionato.
• Deallocations:il conteggio degli oggetti deal allocati tramite free() o Operatore delete durante il periodo di tempo selezionato.
• Dimensioni delle allocazioni: le dimensioni aggregate in byte di tutte le allocazioni durante per il periodo di tempo selezionato.
• Dimensioni deal: le dimensioni aggregate in byte di tutta la memoria liberata. durante il periodo di tempo selezionato.
• Conteggio totale:il valore nella colonna Allocations meno il valore in nella colonna Deallocations.
• Dimensione rimanente: il valore nella colonna Dimensione delle allocazioni meno il valore nella colonna Dimensioni deal.

Per registrare le allocazioni native sui dispositivi con Android 10 e versioni successive: Seleziona Registra allocazioni native, quindi Registra. La registrazione continua finché non fai clic su Interrompi. , Dopo di che la UI di Memory Profiler passa in una schermata separata che mostra la registrazione nativa.

Su Android 9 e versioni precedenti, l'opzione Registra allocazioni native non è disponibili.

Per impostazione predefinita, Native Memory Profiler utilizza una dimensione del campione di 32 byte: vengono allocati 32 byte di memoria, viene acquisito uno snapshot della memoria. R un campione di dimensioni inferiori genera una frequenza maggiore di snapshot, generando una dati accurati sull'utilizzo della memoria. Un campione più grande rende meno preciso ma consumerà meno risorse sul tuo sistema e migliorerà il rendimento durante la registrazione.

Per modificare la dimensione del campione del Profiler di memoria nativo:

1. Seleziona Esegui > Modifica configurazioni.
2. Seleziona il modulo dell'app nel riquadro a sinistra.
3. Fai clic sulla scheda Profilazione e inserisci la dimensione del campione nel campo denominato Intervallo di campionamento della memoria nativa (byte).
4. Crea ed esegui di nuovo l'app.

Acquisisci un dump dell'heap

Un dump dell'heap mostra quali oggetti nella tua app stanno utilizzando memoria nel momento in cui ed acquisire il dump dell'heap. Soprattutto dopo una sessione utente estesa, è stato eseguito un dump dell'heap può aiutare a identificare le fughe di memoria, mostrando gli oggetti ancora in memoria che non dovrebbero più essere presenti.

Dopo aver acquisito un dump dell'heap, puoi visualizzare quanto segue:

• Quali tipi di oggetti sono stati allocati dalla tua app e quanti di essi.
• La quantità di memoria utilizzata da ciascun oggetto.
• Dove si trovano i riferimenti a ciascun oggetto nel codice.
• Lo stack di chiamate per la posizione in cui è stato allocato un oggetto. (Gli stack di chiamate attualmente disponibile con un dump dell'heap solo con Android 7.1 e versioni precedenti quando acquisisci dump dell'heap durante la registrazione delle allocazioni).

Per acquisire un dump dell'heap, fai clic su Acquisisci dump dell'heap, quindi seleziona Registra. Durante il dump dell'heap, la quantità di memoria Java potrebbe aumentare temporaneamente. Questo è normale perché il dump dell'heap si verifica nello stesso processo della tua app e richiede un po' di memoria per raccogliere i dati.

Dopo che il profiler termina l'acquisizione del dump dell'heap, la UI di Memory Profiler le transizioni a una schermata separata che mostra il dump dell'heap.

Figura 5. Visualizzazione del dump dell'heap.

Per specificare in modo più preciso quando viene creato il dump, puoi creare un dump dell'heap nel punto critico del codice dell'app chiamando dumpHprofData().

Nell'elenco dei corsi puoi vedere le seguenti informazioni:

• Allocations: numero di allocazioni nell'heap.

• Dimensioni native: quantità totale di memoria nativa utilizzata da questo tipo di oggetto (in byte). Questa colonna è visibile solo per Android 7.0 e versioni successive.

  Qui vedrai la memoria per alcuni oggetti allocati in Java perché Android utilizza la memoria nativa per alcune classi di framework, come Bitmap.

• Dimensioni superficiali: quantità totale di memoria Java utilizzata dall'oggetto tipo (in byte).

• Dimensioni mantenuta: dimensione totale della memoria che viene mantenuta a causa di tutte le istanze di questa classe (in byte).

Puoi usare i due menu sopra l'elenco degli oggetti allocati per scegliere quali dei dump dell'heap da ispezionare e di come organizzare i dati.

Dal menu a sinistra, scegli quale heap ispezionare:

• heap predefinito: quando il sistema non specifica alcun heap.
• heap di app: l'heap principale su cui l'app alloca la memoria.
• heap immagine: l'immagine di avvio del sistema, contenente le classi è precaricato durante l'avvio. È garantito che le allocazioni in questo punto non vengano mai spostate spariscono.
• heap zygote: l'heap di copia alla scrittura da cui viene generato il fork di un processo dell'app nel sistema Android.

Dal menu a destra, scegli come organizzare le allocazioni:

• Ordina per classe: raggruppa tutte le allocazioni in base al nome della classe. Questo è per impostazione predefinita.
• Ordina per pacchetto: raggruppa tutte le allocazioni in base al nome del pacchetto.
• Disponi per calltack: raggruppa tutte le allocazioni nelle corrispondenti e lo stack di chiamate. Questa opzione funziona solo se acquisisci il dump dell'heap durante la registrazione allocazioni. Anche in questo caso, è probabile che siano presenti oggetti nell'heap assegnate prima di iniziare a registrare, quindi sono visualizzate per prime in base al nome del corso.

Per impostazione predefinita, l'elenco viene ordinato in base alla colonna Dimensioni mantenute. Per ordinare per in un'altra colonna, fai clic sull'intestazione della colonna.

Fai clic sul nome di un corso per aprire la finestra Visualizzazione istanza a destra (come mostrato nella Figura 6). Ogni istanza elencata include quanto segue:

• Profondità: il numero più breve di hop da qualsiasi radice GC al valore selezionato in esecuzione in un'istanza Compute Engine.
• Dimensioni native: le dimensioni di questa istanza nella memoria nativa. Questa colonna è visibile solo per Android 7.0 e versioni successive.
• Dimensioni superficiali: dimensioni di questa istanza nella memoria Java.
• Dimensioni mantenuta: le dimensioni della memoria dominata da questa istanza (in base l'albero del dominio).

Figura 6. La durata richiesta per acquisire un heap il dump è indicato nella sequenza temporale

Per ispezionare l'heap:

1. Sfoglia l'elenco per trovare oggetti con conteggi di heap insolitamente elevati. che potrebbero essere divulgate. Per trovare i corsi noti, fai clic su Nome corso l'intestazione della colonna per ordinare alfabeticamente. Quindi, fai clic sul nome di un corso. La Il riquadro Vista istanze appare sulla destra e mostra ogni istanza della come mostrato nella figura 6.
   • In alternativa, puoi individuare rapidamente gli oggetti facendo clic su Filtra , oppure premendo Ctrl+F (Comando+F su Mac) e inserendo una classe o un pacchetto nel campo di ricerca. Se selezioni questa opzione, puoi anche cercare in base al nome del metodo Ordina in base all'area di chiamata dal menu a discesa. Se vuoi utilizzare la modalità , seleziona la casella accanto a regex. Seleziona la casella accanto a Maiuscole/minuscole se la query di ricerca è sensibile alle maiuscole.
2. Nel riquadro Vista istanza, fai clic su un'istanza. La sezione Riferimenti riportata di seguito, che mostra tutti i riferimenti a quell'oggetto.

   In alternativa, fai clic sulla freccia accanto al nome dell'istanza per visualizzare tutti i campi, quindi fai clic sul nome di un campo. per visualizzarne tutti i riferimenti. Se vuoi visualizzare i dettagli dell'istanza Fai clic con il tasto destro del mouse sul campo e seleziona Vai a istanza.

3. Nella scheda Riferimenti, se identifichi un riferimento che potrebbe essere perdita di memoria, fai clic con il tasto destro del mouse e seleziona Vai all'istanza. Questa operazione seleziona dell'istanza corrispondente dal dump dell'heap, mostrando i dati dell'istanza.

Nel dump dell'heap, cerca le perdite di memoria causate da uno dei seguenti motivi:

• Riferimenti di lunga durata a Activity, Context, View, Drawable e altri oggetti che potrebbero contenere un riferimento al contenitore Activity o Context.
• Classi interne non statiche, come Runnable, che possono contenere un'istanza Activity.
• Cache che contengono gli oggetti più a lungo del necessario.

Salvare un dump dell'heap come file HPROF

Dopo aver acquisito un dump dell'heap, i dati sono visualizzabili solo nel Profiler di memoria mentre il profiler è in esecuzione. Quando esci dalla sessione di profilazione, perdi le dell'heap. Quindi, se vuoi salvarlo per esaminarlo in un secondo momento, esporta il dump dell'heap in un file HPROF. In Android Studio 3.1 e versioni precedenti, la pagina Esporta acquisizione su file Il pulsante si trova sul lato sinistro della barra degli strumenti, sotto la sequenza temporale. nel In Android Studio 3.2 e versioni successive, è presente un pulsante Esporta dump dell'heap nella a destra di ogni voce heap Dump nel riquadro Sessioni. Nella cartella Esporta come salva il file con l'estensione .hprof del nome file.

Per utilizzare un altro analizzatore HPROF, jhat, devi convertire il file HPROF dal formato Android al formato Java SE HPROF. Puoi farlo con lo strumento hprof-conv disponibile nella Directory android_sdk/platform-tools/. Esegui hprof-conv con due argomenti: il file HPROF originale e la posizione in cui scrivere l'HPROF convertito . Ad esempio:

hprof-conv heap-original.hprof heap-converted.hprof

Importa un file di dump dell'heap

Per importare un file HPROF (.hprof), fai clic su Avvia una nuova sessione di profilazione nel Sessioni, seleziona Carica da file e scegli il file dal file del browser.

Puoi anche importare un file HPROF trascinandolo dal browser di file a dell'editor.

Rilevamento di perdite in Memory Profiler

Quando analizzi un dump dell'heap in Memory Profiler, puoi filtrare la profilazione dati che Android Studio ritiene possano indicare perdite di memoria per Activity e Fragment istanze nella tua app.

I tipi di dati mostrati dal filtro includono:

• Activity istanze che sono state eliminate, ma a cui viene ancora fatto riferimento.
• Fragment di istanze che non hanno un valore FragmentManager valido, ma sono ancora a cui si fa riferimento.

In alcune situazioni, ad esempio le seguenti, il filtro potrebbe restituire false positivi:

• Un Fragment è stato creato, ma non è ancora stato utilizzato.
• Un Fragment viene memorizzato nella cache, ma non all'interno di un FragmentTransaction.

Per utilizzare questa funzionalità, devi prima acquisire un dump dell'heap o importa un file di dump dell'heap in Android Studio. per visualizzare i frammenti e le attività che potrebbero perdita di memoria, seleziona la casella di controllo Perdite di attività/frammenti nell'heap riquadro di dump di Memory Profiler, come mostrato nella figura 7.

Figura 7. Filtro di un dump dell'heap per le perdite di memoria.

Tecniche per profilare la tua memoria

Quando usi Memory Profiler, devi applicare stress al codice della tua app e forzare perdite di memoria. Un modo per provocare perdite di memoria nella tua app è lasciarla in esecuzione per un durante l'ispezione dell'heap. Eventuali perdite potrebbero arrivare sulla parte superiore della allocazioni nell'heap. Tuttavia, minore è la perdita, maggiore sarà il tempo necessario eseguire l'app per vederla.

Puoi anche attivare una fuga di memoria in uno dei seguenti modi:

• Ruota il dispositivo più volte da verticale a orizzontale e viceversa gli stati dell'attività. Spesso la rotazione del dispositivo può provocare la perdita di un Activity, Context, oppure View perché il sistema ricrea l'Activity e se app contiene un riferimento a uno di questi oggetti altrove, il sistema non può lo garbage collection.
• Passare dall'app a un'altra app e viceversa quando ci sono diversi stati di attività (vai al schermata Home, quindi torna all'app).

Suggerimento: puoi anche eseguire i passaggi precedenti utilizzando la test monkeyrunner il modello di machine learning.