Warnung: Diese AsyncTask-Klasse sollte statisch sein oder es können Lecks auftreten

Bin ich immer eine Warnung in meinem code, die besagt:

This AsyncTask class should be static or leaks might occur (anonymous android.os.AsyncTask)

Das komplette Warnung:

This AsyncTask class should be static or leaks might occur (anonymous android.os.AsyncTask)
Ein statisches Feld wird Leck Kontexten. Nicht-statische innere Klassen haben eine implizite Referenz auf die äußere Klasse. Wenn das äußere Klasse ist zum Beispiel ein Fragment oder eine Tätigkeit, dann ist dieser Verweis bedeutet, dass die lang andauernde hf/loader/der Aufgabe einen Verweis auf die Aktivität, die verhindert, dass es immer Müll gesammelt. Ähnlich, direkte Referenzen zu den Aktivitäten und Fragmente aus diesen mehr ausgeführten Instanzen können zu Undichtigkeiten führen. ViewModel-Klassen sollten niemals zu Sichten oder nicht-Anwendung Zusammenhängen.

Dies 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 kann ich das korrigieren?

InformationsquelleAutor der Frage Keyur Nimavat | 2017-06-01

31

Nicht-statischen inneren Klasse einen Verweis auf die enthaltende Klasse. Wenn Sie erklären AsyncTask als innere Klasse, es könnte länger Leben als die mit Activity Klasse. Dies ist wegen der implizite Verweis auf die enthaltende Klasse. Dies verhindert, dass die Aktivität aus dem Müll gesammelt, damit die Speicher-Leck.

Um Ihr problem zu lösen, verwenden Sie entweder statisch geschachtelte Klasse statt anonymer, lokale und innere Klassen oder verwenden Sie top-level-Klasse.

InformationsquelleAutor der Antwort Anand

311

Wie die Verwendung einer statischen inneren AsyncTask-Klasse

Um Lecks zu verhindern, können Sie die innere Klasse statisch. Das problem mit, dass, obwohl, ist, dass Sie keinen Zugriff mehr auf die Aktivität der UI-Ansichten oder member-Variablen. Sie können übergeben Sie eine Referenz auf die Context aber dann führen Sie das gleiche Risiko ein Speicherleck. (Android können Sie nicht Müll sammeln, die Aktivität nach dem es schließt, wenn der AsyncTask-Klasse hat einen starken Bezug zur it.) Die Lösung ist, einen schwachen Verweis auf die Aktivität (oder was auch immer Context Sie brauchen).

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;
        }
    }
}

Notes

Soweit ich weiß, diese Art von memory-leak-Gefahr ist immer treu gewesen, aber ich nur sah die Warnung in Android Studio 3.0. Viele der wichtigsten AsyncTask tutorials die es noch nicht mit ihm umgehen (siehe hier hier hierund hier).
Sie würde auch ein ähnliches Verfahren, wenn Ihr AsyncTask waren eine Klasse der obersten Ebene. Eine statische innere Klasse ist im Grunde das gleiche wie eine top-level-Klasse in Java.
Wenn Sie brauchen nicht die Aktivität selbst, aber immer noch wollen, dass der Kontext (z.B. Anzeige eines Toast), die Sie übergeben können, einen Verweis auf die app-Kontext. In diesem Fall ist der AsyncTask Konstruktor könnte so Aussehen:
```
private WeakReference<Application> appReference;

MyTask(Application context) {
    appReference = new WeakReference<>(context);
}
```
Gibt es einige Argumente gibt, die für das ignorieren dieser Warnung und nur unter Verwendung der nicht-statischen Klasse. Nachdem alle, die AsyncTask ist bestimmt sehr kurzer Dauer (ein paar Sekunden am längsten), und es wird release seiner Referenz auf die Aktivität, wenn es fertig ist, sowieso. Sehen diese und diese.
Exzellente Artikel: Wie Leck einen Kontext: Handler & Innere Klassen

InformationsquelleAutor der Antwort Suragch

Diese AsyncTask Klasse sollte statisch sein oder Lecks auftreten, weil

Wenn Activity zerstört wird, AsyncTask (beide static oder non-static) noch läuft
Wenn die innere Klasse ist non-static (AsyncTask) Klasse, es wird die Referenz auf die äußere Klasse (Activity).
Wenn ein Objekt keine Referenzen darauf zeigen, Garbage Collected release wird es. Wenn ein Objekt ist unbenutzt und Garbage Collected kann nicht loslassen => Speicherverlust

=> Wenn AsyncTask ist non-staticActivity nicht loslassen, falls es zerstört => Leck

Lösung für das update-UI nach machen AsyncTask als statische Klasse ohne Leck

1) Verwenden Sie WeakReference wie @Suragch Antwort

2) Senden Sie und entfernen Activity Verweis auf (aus) 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);
        }
    }
}

InformationsquelleAutor der Antwort Phan Van Linh

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.