Introduction

That Android warning appears because a non-static inner AsyncTask holds an implicit reference to its outer Activity or Fragment. If the task outlives the screen that created it, the screen cannot be garbage-collected promptly, which is why lint warns that a memory leak might occur.

Why the Warning Happens

In Java, a non-static inner class automatically keeps a reference to the enclosing instance. So if you write an AsyncTask as an inner class inside an Activity, the task quietly holds onto that Activity.

If the user rotates the device or leaves the screen while the task is still running, the old Activity instance may remain in memory until the task completes. That is the leak pattern the warning is trying to prevent.

The Problematic Pattern

This is the pattern lint complains about:

1public class DetailActivity extends Activity {
2
3    private class LoadTask extends AsyncTask<Void, Void, String> {
4        @Override
5        protected String doInBackground(Void... voids) {
6            return "done";
7        }
8
9        @Override
10        protected void onPostExecute(String result) {
11            TextView label = findViewById(R.id.resultText);
12            label.setText(result);
13        }
14    }
15}

LoadTask implicitly references DetailActivity, so the task can keep the activity alive longer than intended.

Make the Task Static and Use a Weak Reference

The classic fix is to make the task a static inner class and, if it must update the UI, hold a WeakReference to the activity.

1import android.app.Activity;
2import android.os.AsyncTask;
3import android.widget.TextView;
4import java.lang.ref.WeakReference;
5
6public class DetailActivity extends Activity {
7
8    private static class LoadTask extends AsyncTask<Void, Void, String> {
9        private final WeakReference<DetailActivity> activityRef;
10
11        LoadTask(DetailActivity activity) {
12            this.activityRef = new WeakReference<>(activity);
13        }
14
15        @Override
16        protected String doInBackground(Void... voids) {
17            return "done";
18        }
19
20        @Override
21        protected void onPostExecute(String result) {
22            DetailActivity activity = activityRef.get();
23            if (activity == null || activity.isFinishing()) {
24                return;
25            }
26
27            TextView label = activity.findViewById(R.id.resultText);
28            label.setText(result);
29        }
30    }
31}

This removes the implicit outer-class reference and makes it possible for the activity to be collected if needed.

Cancellation Still Matters

A static task reduces the leak risk, but you should still cancel work when the screen no longer needs it.

1public class DetailActivity extends Activity {
2    private LoadTask task;
3
4    @Override
5    protected void onStart() {
6        super.onStart();
7        task = new LoadTask(this);
8        task.execute();
9    }
10
11    @Override
12    protected void onDestroy() {
13        if (task != null) {
14            task.cancel(true);
15        }
16        super.onDestroy();
17    }
18}

That does not guarantee background work stops instantly, but it expresses the lifecycle intent clearly.

AsyncTask Is Deprecated Anyway

Even if you fix the warning correctly, AsyncTask itself is deprecated. New Android code should usually prefer something lifecycle-aware or better-scoped, such as:

• Kotlin coroutines with a ViewModel
• 'ExecutorService plus explicit callbacks'
• WorkManager for deferrable background jobs

The warning is therefore doing two things at once: it points out a real leak pattern, and it nudges you away from an API that modern Android no longer recommends for new code.

Common Pitfalls

One common mistake is making the AsyncTask static but then storing a strong reference to the activity inside it anyway. That defeats the purpose of the change.

Another is updating the UI in onPostExecute without checking whether the activity is still valid. Even if there is no leak, the result can still target a screen that no longer exists logically.

Developers also sometimes keep AsyncTask around in new code because the old examples look simple. Today, it is usually better to move the background work into a more lifecycle-aware abstraction.

Finally, do not assume the warning is purely theoretical. Rotation, back navigation, and slow network calls make this pattern show up in real apps quickly.

Summary

• The warning exists because non-static inner AsyncTask classes keep an implicit reference to their enclosing activity.
• That reference can delay garbage collection and cause leaks when the screen is destroyed.
• A static task plus WeakReference is the classic mitigation.
• Cancellation and lifecycle checks still matter even after the task is made static.
• For new Android code, prefer modern alternatives because AsyncTask is deprecated.