如何避免服务器URL转GIF动画引发的内存泄漏？

I’ve tackled similar memory leak issues with GIF-heavy apps before, so let’s break down actionable solutions to get your memory usage under control:

1. Switch to a Battle-Tested GIF Loading Library #

Manual GIF handling is prone to memory leaks because you’re responsible for every bit of resource management. Libraries like Glide or Fresco are built to handle this efficiently—they automatically recycle bitmaps, manage caches, and respect Android’s lifecycle.

For example, using Glide to load a GIF with lifecycle awareness:

// In your Activity/Fragment
Glide.with(this) // Uses the lifecycle to stop loading when destroyed
    .asGif()
    .load(gifUrl)
    .placeholder(R.drawable.placeholder_static)
    .into(animImageView)

When your view is destroyed, Glide will automatically clear the ImageView’s resources and recycle unused bitmaps. You can also explicitly trigger cleanup with Glide.with(this).clear(animImageView) if needed.

2. Explicitly Recycle Resources in Custom AnimImageView #

If you’re using a custom AnimImageView instead of a library, just setting the view to null isn’t enough. You need to stop animations and recycle drawables when the view detaches from the window:

public class AnimImageView extends ImageView {
    private GifDrawable gifDrawable;

    @Override
    protected void onDetachedFromWindow() {
        super.onDetachedFromWindow();
        // Stop and recycle the GIF drawable
        if (gifDrawable != null) {
            gifDrawable.stop();
            gifDrawable.recycle();
            gifDrawable = null;
        }
        // Clear the ImageView's drawable reference
        setImageDrawable(null);
    }
}

This ensures that when the view is removed from the screen (e.g., scrolling off in a list), all GIF resources are immediately freed.

3. Implement a Limited-Size LRU Cache #

If you’re caching GIFs manually, use an LruCache (Least Recently Used) instead of an unbounded cache. This limits total memory usage by evicting the least recently used GIFs when the cache is full:

// Calculate max cache size (1/8 of available app memory)
val maxMemory = (Runtime.getRuntime().maxMemory() / 1024).toInt()
val cacheSize = maxMemory / 8

val gifCache = object : LruCache<String, GifDrawable>(cacheSize) {
    override fun sizeOf(key: String, value: GifDrawable): Int {
        // Return the GIF's size in KB
        return value.intrinsicHeight * value.intrinsicWidth * 4 / 1024
    }
}

// When loading a GIF:
val cachedGif = gifCache.get(gifUrl)
if (cachedGif != null) {
    animImageView.setImageDrawable(cachedGif)
} else {
    val newGif = loadGifFromUrl(gifUrl)
    gifCache.put(gifUrl, newGif)
    animImageView.setImageDrawable(newGif)
}

This prevents the cache from growing indefinitely and hogging memory.

4. Avoid Strong References in Long-Lived Objects #

Memory leaks often happen when long-lived objects (singletons, background threads, listeners) hold strong references to your AnimImageView or its drawables. Use WeakReference instead to let the garbage collector collect unused views:

// Example listener with a weak reference to the ImageView
class GifLoadListener(imageView: AnimImageView) : OnGifLoadedListener {
    private val imageViewRef = WeakReference(imageView)

    override fun onGifLoaded(gifDrawable: GifDrawable) {
        val imageView = imageViewRef.get()
        imageView?.let {
            it.setImageDrawable(gifDrawable)
        }
    }
}

This way, if the ImageView is destroyed, the listener won’t keep it alive in memory.

5. Throttle GIF Loading for High-Volume Scenarios #

If you’re receiving a flood of GIFs at once, avoid loading all of them immediately:

• Load on demand: Only load a GIF when it enters the user’s viewport (e.g., in a RecyclerView, use onBindViewHolder to load when the item is visible).
• Downsize large GIFs: Resize GIFs to match the ImageView’s dimensions before loading (most libraries like Glide do this automatically).
• Limit concurrent loads: Restrict the number of simultaneous GIF loads to avoid overwhelming memory and network resources.

6. Use Memory Profiling to Pinpoint Leaks #

To confirm what’s causing the leak, use Android Studio’s Memory Profiler:

1. Record a memory snapshot while loading multiple GIFs.
2. Look for instances of GifDrawable or AnimImageView that aren’t being collected after they’re no longer needed.
3. Use LeakCanary to automatically detect leaks and show the reference chain causing the issue.

By combining these strategies, you should see a significant reduction in memory usage and eliminate those annoying卡顿 issues.

内容的提问来源于stack exchange，提问作者O.D