W moim kodzie pojawia się ostrzeżenie:

Ta klasa AsyncTask powinna być statyczna, w przeciwnym razie mogą wystąpić wycieki (anonimowy android.os.AsyncTask)

Pełne ostrzeżenie to:

Ta klasa AsyncTask powinna być statyczna, w przeciwnym razie mogą wystąpić wycieki (anonimowy android.os.AsyncTask) Pole statyczne spowoduje wyciek kontekstów. Niestatyczne klasy wewnętrzne mają niejawne odniesienie do swojej klasy zewnętrznej. Jeśli ta klasa zewnętrzna jest na przykład Fragmentem lub Działaniem, to odwołanie to oznacza, że ​​długo działający moduł obsługi / moduł ładujący / zadanie będzie zawierał odwołanie do działania, które uniemożliwi gromadzenie śmieci. Podobnie bezpośrednie odniesienia pól do działań i fragmentów z tych dłużej działających instancji mogą powodować wycieki. Klasy ViewModel nigdy nie powinny wskazywać na widoki lub konteksty nieaplikacyjne.

To jest mój kod:

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

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

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

            return null;
        }
    }.execute();

Jak to naprawić?

Niestatyczne klasy wewnętrzne zawierają odniesienie do klasy zawierającej. Gdy deklarujesz AsyncTaskjako klasę wewnętrzną, może ona żyć dłużej niż Activityklasa zawierająca . Wynika to z niejawnego odwołania do zawierającej klasy. Zapobiegnie to gromadzeniu śmieci przez działanie, stąd wyciek pamięci.

Aby rozwiązać problem, użyj albo statycznej zagnieżdżonej klasy zamiast anonimowej, lokalnej i wewnętrznej lub użyj klasy najwyższego poziomu.

Jak używać statycznej wewnętrznej klasy AsyncTask

Aby zapobiec wyciekom, możesz ustawić statyczną klasę wewnętrzną. Problem polega na tym, że nie masz już dostępu do widoków interfejsu użytkownika działania lub zmiennych składowych. Możesz przekazać odniesienie do, Contextale wtedy ryzykujesz przeciek pamięci. (Android nie może wyrzucić śmieci po zakończeniu działania, jeśli klasa AsyncTask ma do niego silne odniesienie). Rozwiązaniem jest słabe odwołanie do działania (lub cokolwiek, Contextczego potrzebujesz).

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

Notatki

• O ile mi wiadomo, ten rodzaj wycieku pamięci zawsze był prawdziwy, ale zacząłem widzieć ostrzeżenie tylko w Android Studio 3.0. Wiele głównych AsyncTasksamouczków wciąż nie radzi sobie z tym (patrz tutaj , tutaj , tutaj i tutaj ).
• Podobną procedurę zastosowałbyś również, gdybyś AsyncTaskbył na najwyższym poziomie. Statyczna klasa wewnętrzna jest zasadniczo taka sama jak klasa najwyższego poziomu w Javie.

• Jeśli nie potrzebujesz samego działania, ale nadal chcesz kontekst (na przykład, aby wyświetlić a Toast), możesz przekazać odwołanie do kontekstu aplikacji. W tym przypadku AsyncTaskkonstruktor wyglądałby tak:

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

• Istnieją pewne argumenty przemawiające za zignorowaniem tego ostrzeżenia i po prostu użyciem klasy niestatycznej. W końcu AsyncTask ma trwać bardzo krótko (najdłużej kilka sekund) i po zakończeniu opublikuje swoje odwołanie do działania. Zobacz to i to .
• Doskonały artykuł: Jak wyciec kontekst: Handlery i klasy wewnętrzne

Kotlin

W Kotlin po prostu nie dołączaj innersłowa kluczowego dla klasy wewnętrznej. Domyślnie jest to statyczne.

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

Ta AsyncTaskklasa powinna być statyczna, ponieważ mogą wystąpić przecieki

• Kiedy Activityzostanie zniszczony AsyncTask(oba staticlubnon-static ) nadal działają
• Jeśli klasa wewnętrzna jest klasą non-static( AsyncTask), będzie miała odwołanie do klasy zewnętrznej ( Activity).
• Jeśli obiekt nie ma odniesień do niego, Garbage Collectedzwolni go. Jeśli obiekt nie jest używany i Garbage Collected nie można go zwolnić => pamięć wycieku

=> Jeśli AsyncTasktak non-static, Activitynie zwolni zdarzenia, które zostanie zniszczone => wyciek

Rozwiązanie do aktualizacji interfejsu użytkownika po ustawieniu AsyncTask jako klasy statycznej bez wycieku

1) Użyj WeakReferencejak @ Suragch odpowiedź
2) Wyślij i usuń Activityodniesienie do (z)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);
        }
    }
}