Recibo una advertencia en mi código que dice:

Esta clase AsyncTask debería ser estática o podrían producirse fugas (android.os.AsyncTask anónimo)

La advertencia completa es:

Esta clase AsyncTask debería ser estática o podrían ocurrir 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 ejecución tendrá una referencia a la actividad que evita que se recolecte basura. Del mismo modo, las referencias de campo directas a actividades y fragmentos de estas instancias de ejecución más prolongada pueden provocar fugas. Las clases de ViewModel nunca deben apuntar a Vistas o Contextos que no sean de aplicación.

Este es mi codigo:

 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 contenedora. Cuando declara AsyncTaskcomo una clase interna, puede vivir más que la Activityclase contenedora . Esto se debe a la referencia implícita a la clase contenedora. Esto evitará que la actividad sea recolectada como basura, de ahí 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 utilizar una clase AsyncTask interna estática

Para evitar fugas, puede hacer que la clase interna sea estática. Sin embargo, el problema con eso es que ya no tienes acceso a las vistas de la IU de la Actividad o las variables de miembros. Puede pasar una referencia al Contextpero luego corre el mismo riesgo de pérdida de memoria. (Android no puede recolectar basura la Actividad después de 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 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 yo 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 que existen todavía no tratan con esto (ver aquí , aquí , aquí y aquí ).
• También seguiría un procedimiento similar si AsyncTaskfuera 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 un 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 publicará su referencia a la Actividad cuando finalice de todos modos. Vea esto y Android anonymous asyncTask: ¿causará pérdida de memoria? .
• 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 statico non-static) sigue funcionando
• Si la clase interna es la clase non-static( AsyncTask), tendrá una referencia a la clase externa ( Activity).
• Si un objeto no tiene referencias apunta a él, Garbage Collectedlo liberará. Si un objeto no se utiliza y Garbage Collected no se puede liberar => pérdida de memoria

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

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

1) Use WeakReferencecomo @Suragch respuesta
2) Envíe y elimine la Activityreferencia 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);
        }
    }
}