使用WeakReference优化AsyncTask时，onProgressUpdate频繁调用get会引发内存泄漏吗？

Great question—let's unpack this thoroughly, since balancing AsyncTask's lifecycle with memory safety is a common pain point for Android devs.

First: How to Use WeakReference for Safe Progress Updates #

To safely update your UI progress while avoiding leaks, wrap your Activity/Fragment in a WeakReference when initializing the AsyncTask. Here's a practical example:

public class ProgressTask extends AsyncTask<Void, Integer, Boolean> {
    private final WeakReference<MainActivity> mActivityRef;

    public ProgressTask(MainActivity activity) {
        mActivityRef = new WeakReference<>(activity);
    }

    @Override
    protected Boolean doInBackground(Void... params) {
        // Simulate long-running work with progress ticks
        for (int progress = 0; progress <= 100; progress++) {
            if (isCancelled()) break; // Stop work if task is cancelled
            publishProgress(progress);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return false;
            }
        }
        return true;
    }

    @Override
    protected void onProgressUpdate(Integer... values) {
        super.onProgressUpdate(values);
        // Grab a temporary strong reference to the activity
        MainActivity activity = mActivityRef.get();
        // Only update UI if the activity is still alive
        if (activity != null && !activity.isFinishing()) {
            activity.updateProgressBar(values[0]);
        }
    }

    @Override
    protected void onPostExecute(Boolean success) {
        MainActivity activity = mActivityRef.get();
        if (activity != null && !activity.isFinishing()) {
            activity.showTaskResult(success);
        }
    }
}

Your Questions Answered #

1. Does the strong reference from get() in onProgressUpdate cause memory leaks? #

Absolutely not. Here's the breakdown:

• When you call mActivityRef.get(), you create a temporary strong reference to the activity only for the duration of the onProgressUpdate method.
• Once the method finishes executing, this local strong reference goes out of scope. The only remaining link to the activity is the WeakReference, which doesn't block garbage collection (GC) from reclaiming the activity if it's no longer needed (e.g., the user navigated away).
• Since onProgressUpdate runs on the main thread, its execution is short-lived—no long-lived strong references are created here.

2. Does frequent calls to get() in onProgressUpdate cause memory leaks? #

Nope, frequent calls don't introduce leaks. Here's why:

• Each call to get() just retrieves a temporary strong reference that's discarded as soon as the method finishes.
• The WeakReference itself never holds a strong grip on the activity, so even if you call get() 100 times, the activity can still be GC'd whenever it's no longer referenced elsewhere in your code.
• The only minor downside is negligible performance overhead, but this is never a concern for typical progress update use cases.

Critical Best Practices #

• Always check isCancelled() in doInBackground—this stops unnecessary work if the activity is destroyed.
• Before updating UI in onProgressUpdate or onPostExecute, verify the activity reference is not null and not finishing to avoid NullPointerExceptions.
• Cancel the AsyncTask in your activity's onDestroy() method (task.cancel(true)) to stop background work and prevent stray progress updates.

内容的提问来源于stack exchange，提问作者Florian Walther