Questo documento presuppone che tu abbia seguito le indicazioni sulle best practice per le app per Android in materia di gestione della memoria, ad esempio Gestire la memoria dell'app.
Introduzione
Una fuga di memoria è un tipo di perdita di risorse che si verifica quando un programma per computer non libera la memoria allocata che non è più necessaria. Una perdita può portare l'applicazione a richiedere all'OS più memoria di quella disponibile, causandone l'arresto anomalo. Diverse pratiche improprie possono causare perdite di memoria nelle app per Android, ad esempio la mancata eliminazione corretta delle risorse o la mancata registrazione degli ascoltatori quando non sono più necessari.
Questo documento fornisce alcune best practice per aiutarti a prevenire, rilevare e risolvere le perdite di memoria nel codice. Se hai provato i metodi descritti in questo documento e sospetti una perdita di memoria nei nostri SDK, consulta Come segnalare problemi relativi agli SDK Google.
Prima di contattare l'assistenza
Prima di segnalare una perdita di memoria al team di assistenza di Google, segui le migliori pratiche e i passaggi di debug forniti in questo documento per assicurarti che l'errore non sia nel codice. Questi passaggi potrebbero risolvere il problema. Se non lo risolvono, generano le informazioni di cui il team dell'Assistenza Google ha bisogno per aiutarti.
Evitare perdite di memoria
Segui queste best practice per evitare alcune delle cause più comuni di perdite di memoria nel codice che utilizza gli SDK di Google.
Best practice per le app per Android
Verifica di aver eseguito tutti i seguenti passaggi nella tua applicazione per Android:
- Rilascia le risorse inutilizzate.
- Annullare la registrazione degli ascoltatori quando non sono più necessari.
- Annullare le attività quando non sono necessarie.
- Inoltra i metodi del ciclo di vita per rilasciare le risorse.
- Utilizzare le versioni più recenti degli SDK
Per informazioni specifiche su ciascuna di queste pratiche, consulta le sezioni seguenti.
Rilascia le risorse inutilizzate
Quando la tua app per Android utilizza una risorsa, assicurati di rilasciarla quando non è più necessaria. In caso contrario, la risorsa continuerà a occupare memoria anche al termine dell'utilizzo da parte dell'applicazione. Per saperne di più, consulta la sezione Il ciclo di vita delle attività nella documentazione di Android.
Rilasciare riferimenti GoogleMap obsoleti nei GeoSDK
Un errore comune è che una mappa di Google può causare una perdita di memoria se memorizzata nella cache utilizzando NavigationView o MapView. Un oggetto GoogleMap ha una relazione 1:1 con la NavigationView o la MapView da cui viene recuperato. Devi assicurarti che una mappa Google non venga memorizzata nella cache o che il riferimento venga rilasciato quando viene chiamato NavigationView#onDestroy o MapView#onDestroy. Se utilizzi NavigationSupportFragment, MapSupportFragment o il tuo frammento che racchiude queste visualizzazioni, il riferimento deve essere rilasciato in Fragment#onDestroyView.
class NavFragment : SupportNavigationFragment() {
var googleMap: GoogleMap?
override fun onCreateView(
inflater: LayoutInflater,
parent: ViewGroup?,
savedInstanceState: Bundle?,
): View {
super.onCreateView(inflater,parent,savedInstanceState)
getMapAsync{map -> googleMap = map}
}
override fun onDestroyView() {
googleMap = null
}
}
Annullare la registrazione degli ascoltatori quando non sono più necessari
Quando la tua app per Android registra un ascoltatore per un evento, ad esempio un clic sul pulsante o una modifica dello stato di una visualizzazione, assicurati di annullare la registrazione dell'ascoltatore quando l'applicazione non ha più bisogno di monitorare l'evento. In caso contrario, gli ascoltatori continueranno a occupare memoria anche al termine dell'utilizzo da parte della tua applicazione.
Ad esempio, supponiamo che la tua applicazione utilizzi l'SDK Navigation e chiami il seguente listener per rilevare gli eventi di arrivo: metodo addArrivalListener per rilevare gli eventi di arrivo, deve anche chiamare removeArrivalListener quando non è più necessario monitorare gli eventi di arrivo.
var arrivalListener: Navigator.ArrivalListener? = null
fun registerNavigationListeners() {
arrivalListener =
Navigator.ArrivalListener {
...
}
navigator.addArrivalListener(arrivalListener)
}
override fun onDestroy() {
navView.onDestroy()
if (arrivalListener != null) {
navigator.removeArrivalListener(arrivalListener)
}
...
super.onDestroy()
}
Annullare le attività quando non sono necessarie
Quando un'app per Android avvia un'attività asincrona, ad esempio un download o una richiesta di rete, assicurati di annullarla al termine. Se l'attività non viene annullata, continua a essere eseguita in background anche dopo che l'app ha terminato di utilizzarla.
Per ulteriori dettagli sulle best practice, consulta Gestire la memoria dell'app nella documentazione di Android.
Inoltra i metodi del ciclo di vita per rilasciare le risorse
Se la tua app utilizza l'SDK Navigation o Maps, assicurati di rilasciare le risorse inoltrando i metodi di ciclo di vita (in grassetto) a navView. Puoi farlo utilizzando NavigationView nell'SDK Navigation o MapView nell'SDK Maps o Navigation. Puoi anche utilizzare SupportNavigationFragment o
SupportMapFragment anziché NavigationView e MapView,
rispettivamente. I frammenti di supporto gestiscono inoltro dei metodi di ciclo di vita.
class NavViewActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
...
navView = ...
navView.onCreate(savedInstanceState)
...
}
override fun onSaveInstanceState(savedInstanceState: Bundle) {
super.onSaveInstanceState(savedInstanceState)
navView.onSaveInstanceState(savedInstanceState)
}
override fun onTrimMemory(level: Int) {
super.onTrimMemory(level)
navView.onTrimMemory(level)
}
/* Same with
override fun onStart()
override fun onResume()
override fun onPause()
override fun onConfigurationChanged(...)
override fun onStop()
override fun onDestroy()
*/
}
Utilizza le versioni più recenti degli SDK
Gli SDK Google vengono aggiornati costantemente con nuove funzionalità, correzioni di bug e miglioramenti delle prestazioni. Mantieni aggiornati gli SDK nella tua app per ricevere queste correzioni.
Eseguire il debug delle perdite di memoria
Se continui a riscontrare perdite di memoria dopo aver implementato tutti i suggerimenti applicabili riportati in precedenza in questo documento, segui questa procedura per eseguire il debug.
Prima di iniziare, devi conoscere la modalità di gestione della memoria da parte di Android. Per informazioni, consulta la Panoramica della gestione della memoria di Android.
Per eseguire il debug delle perdite di memoria, segui questa procedura:
- Riproduci il problema. Questo passaggio è essenziale per il debug.
- Controlla se l'utilizzo della memoria è previsto. Verifica che l'aumento dell'utilizzo che sembra essere una perdita non sia in realtà la memoria richiesta per l'esecuzione dell'applicazione.
- Esegui il debug a livello generale. Esistono diverse utilità che puoi utilizzare per eseguire il debug. Tre diversi set di strumenti standard aiutano a eseguire il debug dei problemi di memoria in Android: Android Studio, Perfetto e le utilità a riga di comando Android Debug Bridge (adb).
- Controlla l'utilizzo della memoria dell'app. Ottieni un dump dell'heap e il monitoraggio dell'allocazione, quindi analizzali.
- Risolvi le perdite di memoria.
Le sezioni seguenti illustrano questi passaggi in dettaglio.
Passaggio 1: riproduci il problema
Se non riesci a ricreare il problema, valuta innanzitutto gli scenari che potrebbero causare la perdita di memoria. Se sai che il problema è stato ricreato, potrebbe essere utile esaminare subito un dump dell'heap. Tuttavia, se ricevi solo un dump dell'heap all'avvio dell'app o in un altro momento casuale, è possibile che non siano state attivate le condizioni per attivare una perdita. Valuta la possibilità di provare diversi scenari quando cerchi di ricreare il problema:
Quale insieme di funzionalità è attivato?
Quale sequenza specifica di azioni dell'utente attiva la fuga di dati?
- Hai provato più volte ad attivare questa sequenza?
Quali stati del ciclo di vita ha attraversato l'app?
- Hai provato più iterazioni in stati del ciclo di vita diversi?
Assicurati di poter ricreare il problema nell'ultima versione degli SDK. Il problema di una versione precedente potrebbe essere già stato risolto.
Passaggio 2: controlla se l'utilizzo della memoria per l'app è previsto
Ogni funzionalità richiede memoria aggiuntiva. Quando esegui il debug di diversi scenari, valuta se si tratta di un utilizzo previsto o se si tratta effettivamente di una fuga di memoria. Ad esempio, per funzionalità o attività utente diverse, prendi in considerazione le seguenti possibilità:
Probabile perdita: l'attivazione dello scenario tramite più iterazioni porta a un aumento dell'utilizzo della memoria nel tempo.
Utilizzo della memoria probabilmente previsto: la memoria viene recuperata dopo l'interruzione dello scenario.
Utilizzo della memoria eventualmente previsto: l'utilizzo della memoria aumenta per un determinato periodo di tempo, poi diminuisce. Ciò potrebbe essere dovuto a una cache limitata o a un altro utilizzo della memoria previsto.
Se il comportamento dell'app è probabilmente un utilizzo della memoria previsto, il problema può essere risolto gestendo la memoria dell'app. Per assistenza, consulta Gestire la memoria dell'app.
Passaggio 3: esegui il debug a un livello elevato
Quando esegui il debug di una perdita di memoria, inizia a un livello generale e poi visualizza i dettagli una volta ristrette le possibilità. Utilizza uno di questi strumenti di debugging di alto livello per analizzare innanzitutto se si verifica una perdita nel tempo:
Android Studio Memory Profiler (consigliato)
Memory Profiler di Android Studio
Questo strumento fornisce un'istogramma visivo della memoria utilizzata. Anche i dump heap e il monitoraggio dell'allocazione possono essere attivati dalla stessa interfaccia. Questo strumento è il consiglio predefinito. Per ulteriori informazioni, consulta Android Studio Memory Profiler.
Contatori della memoria di Perfetto
Perfetto ti offre un controllo preciso sul monitoraggio di più metriche e le presenta tutte in un unico istogramma. Per ulteriori informazioni, consulta Contatori della memoria di Perfetto.
Utilità a riga di comando Android Debug Bridge (adb)
Gran parte di ciò che puoi monitorare con Perfetto è disponibile anche come adb
utilità a riga di comando a cui puoi eseguire query direttamente. Ecco alcuni esempi importanti:
Meminfo ti consente di visualizzare informazioni dettagliate sulla memoria in un determinato momento.
Procstats fornisce alcune statistiche aggregate importanti nel tempo.
Una statistica fondamentale da esaminare qui è l'impronta in memoria fisica massima
(maxRSS) richiesta dall'app nel tempo. Il valore MaxPSS potrebbe non essere preciso. Per un modo per aumentare la precisione, consulta il flag adb shell dumpsys procstats --help –start-testing.
Monitoraggio dell'allocazione
Il monitoraggio dell'allocazione identifica l'analisi dello stack in cui è stata allocata la memoria e se non è stata liberata. Questo passaggio è particolarmente utile per rilevare perdite nel codice nativo. Poiché questo strumento identifica la traccia dello stack, può essere un ottimo modo per eseguire rapidamente il debug della causa principale o per capire come ricreare il problema. Per la procedura di utilizzo del monitoraggio dell'allocazione, consulta Eseguire il debug della memoria nel codice nativo con il monitoraggio dell'allocazione.
Passaggio 4: controlla l'utilizzo della memoria dell'app con un dump dell'heap
Un modo per rilevare una perdita di memoria è generare un dump dell'heap della tua app e poi controllarla per rilevare eventuali perdite. Un dump dell'heap è uno snapshot di tutti gli oggetti nella memoria di un'app. Può essere utilizzato per diagnosticare perdite di memoria e altri problemi relativi alla memoria.
Android Studio è in grado di rilevare perdite di memoria non correggibili dal GC. Quando acquisisci un dump dell'heap, Android Studio controlla se è presente un'attività o un frammento ancora raggiungibile, ma già distrutto.
- Acquisisci un dump dell'heap.
- Analizza il dump dell'heap per trovare perdite di memoria.
- Correggere le perdite di memoria.
Per maggiori dettagli, consulta le sezioni seguenti.
Acquisisci un dump dell'heap
Per acquisire un dump dell'heap, puoi utilizzare Android Debug Bridge (adb) o lo strumento di analisi della memoria di Android Studio.
Utilizzare adb per acquisire un dump dell'heap
Per acquisire un dump dell'heap utilizzando adb:
- Collega il dispositivo Android al computer.
- Apri un prompt dei comandi e vai alla directory in cui si trovano gli strumenti adb.
Per acquisire un dump dell'heap, esegui questo comando :
adb shell am dumpheap my.app.name $PHONE_FILE_OUTPer recuperare il dump dell'heap, esegui questo comando:
adb pull $PHONE_FILE_OUT $LOCAL_FILE.
Utilizzare Android Studio per acquisire un dump dell'heap
Per acquisire un dump dell'heap utilizzando lo strumento di analisi della memoria di Android Studio, segui questi passaggi nella sezione Acquisire un dump dell'heap di Android.
Analizza il dump dell'heap per trovare perdite di memoria
Dopo aver acquisito un dump dell'heap, puoi utilizzare lo strumento di profiling della memoria di Android Studio per analizzarlo. Per farlo, segui questi passaggi:
Apri il progetto Android in Android Studio.
Seleziona Esegui e poi la configurazione Debug.
Apri la scheda Android Profiler.
Seleziona Memoria.
Seleziona Apri dump dell'heap e seleziona il file del dump dell'heap che hai generato. Il profiler della memoria mostra un grafico dell'utilizzo della memoria dell'app.
Utilizza il grafico per analizzare il dump dell'heap:
Identifica gli oggetti che non vengono più utilizzati.
Identifica gli oggetti che utilizzano molta memoria.
Scopri quanta memoria utilizza ogni oggetto.
Utilizza queste informazioni per restringere o trovare la fonte della perdita di memoria e correggerla.
Passaggio 5: correggi le perdite di memoria
Una volta identificata la causa della perdita di memoria, puoi risolverla. La correzione delle perdite di memoria nelle app per Android contribuisce a migliorare le prestazioni e la stabilità delle app. A seconda dello scenario, i dettagli variano. Tuttavia, i seguenti suggerimenti possono esserti utili:
Assicurati che la tua app allochi e deallochi la memoria come consigliato dall'argomento Android Gestire la memoria dell'app.
Rimuovi codice o risorse inutilizzati dall'app. Per informazioni dettagliate sulle app per Android, consulta le best practice per le app per Android.
Altri strumenti di debug
Al termine di questi passaggi, se non hai ancora trovato e corretto la perdita di memoria, prova questi strumenti:
- Esegui il debug della memoria nel codice nativo con il monitoraggio dell'allocazione.
- Identifica le fughe di dati con LeakCanary.
Esegui il debug della memoria nel codice nativo con il monitoraggio dell'allocazione
Anche se non utilizzi direttamente il codice nativo, diverse librerie Android comuni lo fanno, inclusi gli SDK di Google. Se ritieni che la perdita di memoria si trovi nel codice nativo, esistono diversi strumenti che puoi utilizzare per eseguire il debug. Il monitoraggio dell'allocazione con Android Studio o heapprofd (compatibile anche con Perfetto) è un ottimo modo per identificare le potenziali cause di una perdita di memoria ed è spesso il modo più rapido per eseguire il debug.
Il monitoraggio dell'allocazione ha anche il vantaggio di consentirti di condividere i risultati senza includere informazioni sensibili che possono essere trovate in un heap.
Identificare le perdite con LeakCanary
LeakCanary è uno strumento potente per identificare le perdite di memoria nelle app per Android. Per scoprire di più su come utilizzare LeakCanary nella tua app, visita LeakCanary.
Come segnalare problemi relativi agli SDK di Google
Se hai provato i metodi descritti in questo documento e sospetti una perdita di memoria nei nostri SDK, contatta l'assistenza clienti fornendo quante più informazioni possibili tra le seguenti:
Passaggi per ricreare la perdita di memoria. Se i passaggi richiedono una codifica complessa, potrebbe essere utile copiare il codice che replica il problema nella nostra app di esempio e fornire i passaggi aggiuntivi da seguire nell'interfaccia utente per attivare la perdita.
Dump dell'heap acquisiti dalla tua app con il problema ricreato. Acquisisci dump dell'heap in due momenti diversi che mostrano che l'utilizzo della memoria è aumentato in modo significativo.
Se è prevista una perdita di memoria nativa, condividi l'output del monitoraggio dell'allocazione di heapprofd.
Una segnalazione di bug effettuata dopo aver ricreato la condizione di perdita.
Tracce dello stack di eventuali arresti anomali correlati alla memoria.
Nota importante: in genere le analisi dello stack non sono sufficienti da sole per eseguire il debug di un problema di memoria, quindi assicurati di fornire anche una delle altre forme di informazioni.