Best practice di gestione della memoria

Questo documento presuppone che tu abbia seguito le indicazioni sulle best practice per le app per Android per la gestione della memoria, Gestire la memoria dell'app.

Introduzione

Una fuga di memoria è un tipo di fuga di risorse che si verifica quando un computer non rilascia memoria allocata che non è più necessaria. Infiltrazione può portare l'applicazione a richiedere al sistema operativo più memoria di quanta ne abbia disponibili, causando così l'arresto anomalo dell'applicazione. Varie pratiche improprie possono causare fughe di memoria nelle app per Android, ad esempio lo smaltimento non corretto o di non annullare la registrazione dei listener quando non sono più necessari.

Questo documento fornisce alcune best practice per prevenire, rilevare e risolvere le perdite di memoria nel codice. Se hai provato i metodi indicati in questa documentare e sospettare una perdita di memoria nei nostri SDK, vedi Come segnalare problemi relativi agli SDK Google.

Prima di contattare l'assistenza

Prima di segnalare una perdita di memoria al team dell'Assistenza Google, segui le best practice e i passaggi di debug forniti in questo documento per assicurati che l'errore non sia nel tuo codice. Questa procedura potrebbe risolvere il problema e se non lo fanno, generano le informazioni di cui il team dell'Assistenza Google ha bisogno che ti aiutino.

Previeni le fughe di memoria

Segui queste best practice per evitare alcune delle cause più comuni di perdite di memoria nel codice che usa gli SDK Google.

Best practice per le app per Android

Verifica di avere svolto tutte le seguenti operazioni nell'applicazione Android:

1. Rilascia le risorse inutilizzate.
2. Annulla la registrazione dei listener quando non sono più necessari.
3. Annulla le attività quando non sono necessarie.
4. Inoltra i metodi del ciclo di vita per rilasciare risorse.
5. Utilizzare le versioni più recenti degli SDK

Per dettagli specifici su ciascuna di queste pratiche, consulta le sezioni seguenti.

Rilascia risorse inutilizzate

Quando la tua app per Android utilizza una risorsa, assicurati di rilasciarla nel momento in cui non è più necessario. In caso contrario, la risorsa continuerà a occupare memoria anche al termine dell'applicazione. Per ulteriori informazioni, consulta Il ciclo di vita dell'attività nella documentazione di Android.

Rilascia riferimenti GoogleMap inattivi in GeoSDK

Un errore comune è che una mappa di Google Maps può causare una perdita di memoria se memorizzata nella cache NavigationView o MapView. Una mappa di Google Maps ha una relazione 1:1 con NavigazioneView o MapView da cui viene recuperata. Tu deve garantire che una mappa di Google Maps non sia memorizzata nella cache o che il riferimento sia viene rilasciato quando viene chiamato NavigationView#onDestroy o MapView#onDestroy. Se utilizzando NavigationSupportFragment, MapSupportFragment o il tuo frammento che raggruppano queste viste, il riferimento deve essere rilasciato 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
  }
}

Annulla la registrazione dei listener quando non sono più necessari

Quando la tua app per Android registra un listener per un evento, ad esempio un pulsante. un clic o una modifica dello stato di una vista, assicurati di annullare la registrazione del listener quando l'applicazione non ha più bisogno di monitorare l'evento. In caso contrario, i listener continuano a occupare memoria anche al termine dell'applicazione con loro.

Ad esempio, supponiamo che la tua applicazione utilizzi l'SDK di navigazione e chiami il seguente listener per ascoltare gli eventi di arrivo: addArrivalListener per ascoltare gli eventi di arrivo, deve anche chiamare removeArrivalListener quando non è più necessario monitorare gli eventi in 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()
}

Annulla le attività quando non sono necessarie

Quando un'app per Android avvia un'attività asincrona, come un download o un una richiesta di rete, assicurati di annullare l'attività al termine. Se l'attività non viene annullato, continua a essere eseguito in background anche dopo ha finito.

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 risorse

Se la tua app utilizza l'SDK di navigazione o Maps, assicurati di rilasciare l'elemento inoltrando i metodi del ciclo di vita (mostrati in grassetto) a navView. Puoi esegui questa operazione utilizzando NavigationView nell'SDK di navigazione oppure MapView in Maps o SDK di navigazione. Puoi anche usare SupportNavigationFragment o SupportMapFragment anziché utilizzare direttamente NavigationView e MapView, rispettivamente. I frammenti di supporto gestiscono l'inoltro del ciclo di vita di classificazione.

Nota: NavViewActivity nel seguente codice si riferisce a un modello l'attività che potresti creare.

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()
  */
}

Utilizzare le versioni più recenti degli SDK

Gli SDK Google vengono costantemente aggiornati con nuove funzionalità, correzioni di bug e miglioramenti delle prestazioni. Per ricevere questi SDK, mantieni aggiornati gli SDK nell'app correzioni.

Debug delle fughe di memoria

Se noti ancora perdite di memoria dopo aver implementato tutte le suggerimenti precedenti in questo documento, segui questa procedura per eseguire il debug.

Prima di iniziare, dovresti conoscere il modo in cui Android gestisce la memoria. Per informazioni, leggi l'app Android Panoramica della gestione della memoria.

Per eseguire il debug delle fughe di memoria, segui questa procedura:

1. Ricrea il problema. Questo passaggio è essenziale per il debug.
2. Controlla se l'utilizzo della memoria è previsto. Verifica che l'aumento dell'utilizzo, che sembra essere una fuga di dati, non è in realtà la memoria necessaria per eseguire l'applicazione.
3. Esegui il debug a livello generale. Esistono diverse utilità che per il debug. Tre diversi set di strumenti standard consentono di eseguire il debug dei problemi di memoria in Android: Android Studio, Perfetto e Android Debug Bridge (adb) utilità della riga di comando.
4. Controlla la memoria utilizzata dall'app. Recuperare un dump dell'heap monitoraggio dell'allocazione e poi analizzarlo.
5. Risolvi le perdite di memoria.

Questi passaggi vengono descritti in dettaglio nelle sezioni seguenti.

Passaggio 1: ricrea il problema

Se non sei riuscito a ricreare il problema, considera innanzitutto gli scenari che potrebbero causare perdite di memoria. per guardare subito un dump dell'heap potrebbe funzionare, se sai che il problema è stato ricreato. Tuttavia, se si ottiene un dump dell'heap all'avvio dell'app o un altro momento casuale, potresti non aver attivato le condizioni per attivare una fuga di dati. Prendi in considerazione di analizzare vari scenari quando si cerca di ricreare il problema:

• Quale insieme di funzionalità vengono attivate?

• Quale sequenza specifica di azioni degli utenti provoca la fuga di dati?

  • Hai provato più volte ad attivare questa sequenza?

• Quali stati del ciclo di vita è stato attraversato dall'app?

  • Hai provato più iterazioni con stati del ciclo di vita diversi?

Assicurati di poter ricreare il problema nell'ultima versione degli SDK. La 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 meno di fuga di memoria. Ad esempio, per le diverse funzionalità o attività utente, considera la le seguenti possibilità:

• Probabile fuga di dati:attivazione dello scenario tramite più iterazioni comporta un aumento dell'utilizzo della memoria nel tempo.

• Utilizzo della memoria probabile: la memoria viene recuperata dopo lo scenario viene interrotto.

• Possibile utilizzo della memoria previsto: aumenti dell'utilizzo della memoria per un periodo di per poi diminuire. Ciò potrebbe essere dovuto a una cache limitata o ad altre memoria utilizzata.

Se il comportamento dell'app è probabilmente l'utilizzo previsto della memoria, il problema può essere risolti gestendo la memoria dell'app. Per assistenza, vedi Gestire la memoria dell'app.

Passaggio 3: esegui il debug a livello generale

Quando esegui il debug di una perdita di memoria, inizia a livello generale e poi visualizza in dettaglio dopo aver ristretto le possibilità. Utilizza una delle seguenti opzioni Strumenti di debug per l'analisi iniziale di eventuali perdite nel tempo:

• Profilo della memoria di Android Studio (consigliato)

• Contatori memoria Perfetto

• Utilità della riga di comando Android Debug Bridge (adb)

• Monitoraggio dell'allocazione

Profiler di memoria di Android Studio

Questo strumento fornisce un istogramma visivo della memoria consumata. Dump dell'heap e monitoraggio dell'allocazione possono essere attivati da questa stessa interfaccia. Questo è il suggerimento predefinito. Per ulteriori informazioni, vedi Profilo memoria di Android Studio.

Contatori memoria Perfetto

Perfetto ti offre un controllo preciso sul monitoraggio di più metriche, presentandole in un unico istogramma. Per ulteriori informazioni, vedi Contatori memoria Perfetto.

Utilità della riga di comando del bridge di debug Android (adb)

Gran parte di ciò che puoi tracciare con Perfetto è disponibile anche come adb a riga di comando su cui puoi eseguire query direttamente. Un paio di aspetti Ecco alcuni esempi:

• Meminfo ti consente di vedere informazioni dettagliate sulla memoria in un determinato momento.

• Procstats fornisce alcune importanti statistiche aggregate nel tempo.

Una statistica fondamentale da esaminare in questo caso è l'impronta di memoria fisica massima (maxRSS) che l'app richiede nel tempo. Il valore MaxPSS potrebbe non essere così preciso. Per un modo per aumentare la precisione, adb shell dumpsys procstats --help –start-testing flag.

Monitoraggio allocazione

Il monitoraggio dell'allocazione identifica l'analisi dello stack in cui è stata allocata la memoria. se non fosse stato liberato. Questo passaggio è particolarmente utile per individuare le perdite nei il codice nativo. Poiché questo strumento identifica l'analisi dello stack, può essere un'ottima soluzione significa eseguire rapidamente il debug della causa principale o capire come ricreare il problema. Per conoscere la procedura per utilizzare il monitoraggio dell'allocazione, consulta: Memoria di debug nel codice nativo con 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 è eseguire un dump dell'heap dell'app e quindi controlla che non ci siano perdite. Un dump dell'heap è uno snapshot di tutti gli oggetti nella memoria di un'app. Può essere usato per diagnosticare perdite di memoria e altre problemi di memoria.

Nota: le app per Android scritte in Java o Kotlin utilizzano una garbage collector (GC) per gestire la memoria utilizzata dalle app. Il documento GC identifica e rimuove automaticamente gli oggetti non più tempo (ovvero oggetti che non sono raggiungibile da qualsiasi radice). In questo modo si libera memoria che può essere utilizzata da altri.

Poiché le app Java e Kotlin utilizzano un garbage collector, potresti chiederti in che modo possono essere perdite di memoria. Il Garbage Collection non dovrebbe recuperare tutti gli oggetti irraggiungibili? Nella Android, le fughe di memoria di solito si riferiscono a oggetti raggiungibili che non sono più utile. Ad esempio, se la tua app conserva un riferimento a un'attività Android che è stata distrutta, è considerata una perdita, perché l'attività non può visualizzato di nuovo, ma GC non può rivendicarlo perché è ancora di proprietà del tuo dell'app. Un'attività spesso è costosa da tenere in memoria.

Android Studio è in grado di rilevare perdite di memoria non risolvibili da GC. Quando acquisisci un dump dell'heap, Android Studio controlla se è presente un'attività o un frammento che è ancora raggiungibile ma che è già stata distrutta.

1. Acquisisci un dump dell'heap.
2. Analizza il dump dell'heap per individuare le perdite di memoria.
3. Risolvi 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 Profiler di memoria di Android Studio.

Utilizza adb per acquisire un dump dell'heap

Per acquisire un dump dell'heap utilizzando adb, segui questi passaggi:

1. Collega il dispositivo Android al computer.
2. Apri un prompt dei comandi e vai alla directory in cui si trovano gli strumenti ADB.

3. Per acquisire un dump dell'heap, esegui questo comando :

   adb shell am dumpheap my.app.name $PHONE_FILE_OUT

4. Per 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 il Profiler di memoria di Android Studio, segui questi passaggi passi in Android Acquisire un heapdump .

Analizza il dump dell'heap per individuare le perdite di memoria

Dopo aver acquisito un dump dell'heap, puoi utilizzare la classe di archiviazione Profiler per analizzarlo. Per farlo, segui questi passaggi:

1. Apri il tuo progetto Android in Android Studio.

2. Seleziona Esegui e poi la configurazione Debug.

3. Apri la scheda Android Profiler.

4. Seleziona Memoria.

5. Seleziona Apri dump dell'heap e seleziona il file di dump dell'heap che hai generato. Il profiler di memoria mostra un grafico della memoria utilizzata dalla tua app.

6. 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 la quantità di memoria utilizzata da ciascun oggetto.

7. Utilizza queste informazioni per restringere o trovare l'origine della perdita di memoria e correggilo.

Nota: un problema noto in Android Studio, le dimensioni mantenute registrate non sono precise. Le dimensioni può essere molto sottovalutato o sovrastimato a seconda della versione Android Studio. Google consiglia di utilizzare dimensioni di base per l'analisi della memoria.

Passaggio 5: correggi le perdite di memoria

Dopo aver identificato l'origine della perdita di memoria, puoi correggerla. La correzione delle perdite di memoria nelle app Android consente di migliorare le prestazioni e la stabilità delle tue app. I dettagli variano a seconda dello scenario. Tuttavia, i seguenti suggerimenti possono essere utili:

• Assicurati che la tua app allochi e dealhi la memoria come consigliato l'argomento Android Gestire la memoria dell'app.

• Rimuovi risorse o codice inutilizzati dalla tua app. Per informazioni dettagliate sulle app per Android, consulta le best practice per le app Android.

Altri strumenti di debug

Una volta completati questi passaggi, se ancora non hai trovato e corretto i perdita di memoria, prova questi strumenti:

• Memoria di debug nel codice nativo con monitoraggio dell'allocazione.
• Identifica le fughe di informazioni con LeakCanary.

Memoria di debug nel codice nativo con monitoraggio dell'allocazione

Anche se non usi direttamente il codice nativo, diverse librerie Android comuni che possono fare, inclusi gli SDK Google. Se pensi che la perdita di memoria sia nel codice nativo, ci sono vari strumenti che puoi utilizzare per eseguirne 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 offre anche il vantaggio distinto di condividere senza includere informazioni sensibili presenti in un heap.

Identifica le fughe di notizie con LeakCanary

LeakCanary è un potente strumento per identificare le perdite di memoria nelle app per Android. Per scoprire di più su come utilizzare LeakCanary nella tua app, visita LeakCanary.

Nota: informazioni su LeakCanary e sugli SDK Google Maps o Navigatore. Dopo un o un frammento con un MapView viene eliminato, Maps SDK o L'SDK di navigazione potrebbe conservarlo per un minuto al massimo per la registrazione. Poiché LeakCanary rileva perdite immediatamente dopo un'attività o un frammento viene distrutto, potrebbe segnalare l'attività o il frammento come una fuga. Google consiglia di attendere un minuto e poi di acquisire un dump dell'heap per vedere se l'attività o il frammento distrutti sono ancora nella memoria.

Come segnalare problemi con gli SDK Google

Se hai provato i metodi descritti in questo documento e sospetti una perdita di memoria nei nostri SDK, contatta l'assistenza clienti fornendo il maggior numero possibile delle seguenti informazioni il più possibile:

• Passaggi per ricreare la perdita di memoria. Se i passaggi richiedono una programmazione complessa, può essere utile copiare il codice che replica il problema nella nostra app di esempio e indica i passaggi aggiuntivi da eseguire nell'interfaccia utente per attivare perdita di dati.

• Dump dell'heap acquisiti dalla tua app con il problema ricreato. Acquisisci heap in due diversi momenti che mostrano che l'utilizzo della memoria è aumentati in modo sostanziale.

• Se è prevista una perdita di memoria nativa, condividi l'allocazione di monitoraggio dell'output heapprofd

• Una segnalazione di bug eseguita dopo aver ricreato la condizione di perdita.

• Analisi dello stack di eventuali arresti anomali relativi alla memoria.

  Nota importante: in genere le analisi dello stack non sono sufficienti per eseguire il debug di un problema di memoria, quindi assicurati di specificare anche uno degli altri moduli di informazioni.