Recibo una advertencia en mi código que dice:

Esta clase AsyncTask debe ser estática o pueden producirse fugas (anónimo android.os.AsyncTask)

La advertencia completa es:

Esta clase AsyncTask debería ser estática o podrían producirse fugas (android.os.AsyncTask anónimo) Un campo estático filtrará contextos. Las clases internas no estáticas tienen una referencia implícita a su clase externa. Si esa clase externa es, por ejemplo, un Fragmento o Actividad, entonces esta referencia significa que el manejador / cargador / tarea de larga duración mantendrá una referencia a la actividad que evita que se recolecte basura. Del mismo modo, las referencias directas de campo a actividades y fragmentos de estas instancias de ejecución más prolongada pueden causar fugas. Las clases ViewModel nunca deben apuntar a Vistas o Contextos que no sean de aplicación.

Este es mi código:

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

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

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

            return null;
        }
    }.execute();

¿Cómo corrijo esto?

Las clases internas no estáticas contienen una referencia a la clase que lo contiene. Cuando declarasAsyncTask como una clase interna, puede vivir más tiempo que la Activityclase que lo contiene . Esto se debe a la referencia implícita a la clase que lo contiene. Esto evitará que la actividad se recolecte basura, por lo tanto, la pérdida de memoria.

Para resolver su problema, use la clase anidada estática en lugar de la clase anónima, local e interna o use la clase de nivel superior.

Cómo usar una clase AsyncTask interna estática

Para evitar fugas, puede hacer que la clase interna sea estática. El problema con eso, sin embargo, es que ya no tiene acceso a las vistas de UI de la Actividad o las variables miembro. Puede pasar una referencia al Contextpero luego corre el mismo riesgo de una pérdida de memoria. (Android no puede recolectar basura de la Actividad una vez que se cierra si la clase AsyncTask tiene una fuerte referencia a ella). La solución es hacer una referencia débil a la Actividad (o lo Contextque sea que necesite).

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

Notas

• Hasta donde sé, este tipo de peligro de pérdida de memoria siempre ha sido cierto, pero solo comencé a ver la advertencia en Android Studio 3.0. Muchos de los AsyncTasktutoriales principales aún no se tratan (ver aquí , aquí , aquí y aquí ).
• También seguiría un procedimiento similar si su AsyncTask fuera una clase de nivel superior. Una clase interna estática es básicamente lo mismo que una clase de nivel superior en Java.

• Si no necesita la Actividad en sí pero aún desea el Contexto (por ejemplo, para mostrar a Toast), puede pasar una referencia al contexto de la aplicación. En este caso, el AsyncTaskconstructor se vería así:

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

• Existen algunos argumentos para ignorar esta advertencia y simplemente usar la clase no estática. Después de todo, AsyncTask está destinado a ser de muy corta duración (un par de segundos como máximo) y, de todos modos, liberará su referencia a la Actividad cuando termine. Ver esto y esto .
• Excelente artículo: Cómo filtrar un contexto: controladores y clases internas

Kotlin

En Kotlin simplemente no incluya la innerpalabra clave para la clase interna. Esto lo hace estático por defecto.

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

Esta AsyncTaskclase debe ser estática o se pueden producir fugas porque

• Cuando Activityse destruye, AsyncTask(ambos staticonon-static ) siguen ejecutándose
• Si la clase interna es la clase non-static( AsyncTask), tendrá referencia a la clase externa ( Activity).
• Si un objeto no tiene referencias, apúntelo, Garbage Collectedlo liberará. Si un objeto no se usa y Garbage Collected no puede liberarlo => pérdida de memoria

=> Si AsyncTaskes así non-static, Activityno se lanzará el evento se destruye => fuga

Solución para actualizar la interfaz de usuario después de hacer AsyncTask como clase estática sin fugas

1) Usar WeakReferencecomo respuesta @Suragch
2) Enviar y eliminar Activityreferencias a (desde)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);
        }
    }
}