In meinem Code wird eine Warnung angezeigt, die besagt:

Diese AsyncTask-Klasse sollte statisch sein, da sonst Lecks auftreten können (anonym android.os.AsyncTask)

Die vollständige Warnung lautet:

Diese AsyncTask-Klasse sollte statisch sein, da sonst Lecks auftreten können (anonym android.os.AsyncTask). Ein statisches Feld leckt Kontexte. Nicht statische innere Klassen haben einen impliziten Verweis auf ihre äußere Klasse. Wenn diese äußere Klasse beispielsweise ein Fragment oder eine Aktivität ist, bedeutet diese Referenz, dass der lang laufende Handler / Loader / Task einen Verweis auf die Aktivität enthält, der verhindert, dass Müll gesammelt wird. In ähnlicher Weise können direkte Feldverweise auf Aktivitäten und Fragmente dieser länger laufenden Instanzen zu Lecks führen. ViewModel-Klassen sollten niemals auf Ansichten oder Nichtanwendungskontexte verweisen.

Das ist mein Code:

 new AsyncTask<Void,Void,Void>(){

        @Override
        protected Void doInBackground(Void... params) {
            runOnUiThread(new Runnable() {

                @Override
                public void run() {
                    mAdapter.notifyDataSetChanged();
                }
            });

            return null;
        }
    }.execute();

Wie korrigiere ich das?

Nicht statische innere Klassen enthalten einen Verweis auf die enthaltende Klasse. Wenn Sie AsyncTaskals innere Klasse deklarieren , lebt sie möglicherweise länger als die enthaltende ActivityKlasse. Dies liegt an der impliziten Bezugnahme auf die enthaltende Klasse. Dies verhindert, dass die Aktivität durch Müll gesammelt wird, daher der Speicherverlust.

Verwenden Sie zur Lösung Ihres Problems entweder eine statisch verschachtelte Klasse anstelle einer anonymen, lokalen und inneren Klasse oder eine Klasse der obersten Ebene.

Verwendung einer statischen inneren AsyncTask-Klasse

Um Undichtigkeiten zu vermeiden, können Sie die innere Klasse statisch machen. Das Problem dabei ist jedoch, dass Sie keinen Zugriff mehr auf die Benutzeroberflächenansichten oder Mitgliedsvariablen der Aktivität haben. Sie können einen Verweis auf das übergeben, Contextaber dann besteht das gleiche Risiko eines Speicherverlusts. (Android kann die Aktivität nach dem Schließen nicht mit Müll sammeln, wenn die AsyncTask-Klasse einen starken Verweis darauf hat.) Die Lösung besteht darin, einen schwachen Verweis auf die Aktivität (oder was auch immer ContextSie benötigen) zu erstellen .

public class MyActivity extends AppCompatActivity {

    int mSomeMemberVariable = 123;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // start the AsyncTask, passing the Activity context
        // in to a custom constructor 
        new MyTask(this).execute();
    }

    private static class MyTask extends AsyncTask<Void, Void, String> {

        private WeakReference<MyActivity> activityReference;

        // only retain a weak reference to the activity 
        MyTask(MyActivity context) {
            activityReference = new WeakReference<>(context);
        }

        @Override
        protected String doInBackground(Void... params) {

            // do some long running task...

            return "task finished";
        }

        @Override
        protected void onPostExecute(String result) {

            // get a reference to the activity if it is still there
            MyActivity activity = activityReference.get();
            if (activity == null || activity.isFinishing()) return;

            // modify the activity's UI
            TextView textView = activity.findViewById(R.id.textview);
            textView.setText(result);

            // access Activity member variables
            activity.mSomeMemberVariable = 321;
        }
    }
}

Anmerkungen

• Soweit ich weiß, war diese Art von Speicherverlustgefahr immer wahr, aber ich habe die Warnung erst in Android Studio 3.0 gesehen. Viele der wichtigsten AsyncTaskTutorials da draußen beschäftigen sich immer noch nicht damit (siehe hier , hier , hier und hier ).
• Sie würden auch ein ähnliches Verfahren anwenden, wenn Sie AsyncTaskeine erstklassige Klasse wären . Eine statische innere Klasse ist im Grunde dieselbe wie eine Klasse der obersten Ebene in Java.

• Wenn Sie die Aktivität selbst nicht benötigen, aber dennoch den Kontext möchten (z. B. um a anzuzeigen Toast), können Sie einen Verweis auf den App-Kontext übergeben. In diesem Fall würde der AsyncTaskKonstruktor folgendermaßen aussehen:

  private WeakReference<Application> appReference;
  
  MyTask(Application context) {
      appReference = new WeakReference<>(context);
  }

• Es gibt einige Argumente dafür, diese Warnung zu ignorieren und nur die nicht statische Klasse zu verwenden. Immerhin soll die AsyncTask sehr kurzlebig sein (höchstens ein paar Sekunden), und sie wird ihren Verweis auf die Aktivität freigeben, wenn sie trotzdem beendet ist. Sehen Sie dies und das .
• Ausgezeichneter Artikel: Wie man einen Kontext verliert: Handler & innere Klassen

Kotlin

Geben Sie in Kotlin einfach nicht das innerSchlüsselwort für die innere Klasse an. Dies macht es standardmäßig statisch.

class MyActivity : AppCompatActivity() {

    internal var mSomeMemberVariable = 123

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // start the AsyncTask, passing the Activity context
        // in to a custom constructor
        MyTask(this).execute()
    }

    private class MyTask
    internal constructor(context: MyActivity) : AsyncTask<Void, Void, String>() {

        private val activityReference: WeakReference<MyActivity> = WeakReference(context)

        override fun doInBackground(vararg params: Void): String {

            // do some long running task...

            return "task finished"
        }

        override fun onPostExecute(result: String) {

            // get a reference to the activity if it is still there
            val activity = activityReference.get()
            if (activity == null || activity.isFinishing) return

            // modify the activity's UI
            val textView = activity.findViewById(R.id.textview)
            textView.setText(result)

            // access Activity member variables
            activity.mSomeMemberVariable = 321
        }
    }
}

Diese AsyncTaskKlasse sollte statisch sein, da sonst Lecks auftreten können

• Wenn Activityzerstört wird, laufen AsyncTask(beide staticoder non-static) noch
• Wenn die innere Klasse die Klasse non-static( AsyncTask) ist, verweist sie auf die äußere Klasse ( Activity).
• Wenn auf ein Objekt kein Verweis verweist, Garbage Collectedwird es freigegeben. Wenn ein Objekt nicht verwendet wird und Garbage Collected es nicht freigeben kann => Speicherverlust

=> Wenn AsyncTaskja non-static, Activitywird das Ereignis nicht freigegeben, es wird zerstört => Leck

Lösung für die Aktualisierung der Benutzeroberfläche, nachdem AsyncTask als statische Klasse ohne Leck erstellt wurde

1) Verwenden Sie WeakReferencewie @ Suragch Antwort
2) Senden und entfernen Sie ActivityVerweise auf (von)AsyncTask

public class NoLeakAsyncTaskActivity extends AppCompatActivity {
    private ExampleAsyncTask asyncTask;

    @Override 
    protected void onCreate(Bundle savedInstanceState) {
        ...

        // START AsyncTask
        asyncTask = new ExampleAsyncTask();
        asyncTask.setListener(new ExampleAsyncTask.ExampleAsyncTaskListener() {
            @Override
            public void onExampleAsyncTaskFinished(Integer value) {
                // update UI in Activity here
            }
        });
        asyncTask.execute();
    }

    @Override
    protected void onDestroy() {
        asyncTask.setListener(null); // PREVENT LEAK AFTER ACTIVITY DESTROYED
        super.onDestroy();
    }

    static class ExampleAsyncTask extends AsyncTask<Void, Void, Integer> {
        private ExampleAsyncTaskListener listener;

        @Override
        protected Integer doInBackground(Void... voids) {
            ...
            return null;
        }

        @Override
        protected void onPostExecute(Integer value) {
            super.onPostExecute(value);
            if (listener != null) {
                listener.onExampleAsyncTaskFinished(value);
            }
        }

        public void setListener(ExampleAsyncTaskListener listener) {
            this.listener = listener;
        }

        public interface ExampleAsyncTaskListener {
            void onExampleAsyncTaskFinished(Integer value);
        }
    }
}