问题 ListView中的图像延迟加载

我做了 一个懒惰列表的简单演示 （位于GitHub）有图像。这可能对某人有帮助。它在后台线程中下载图像。图像正在缓存在SD卡和内存中。缓存实现非常简单，仅适用于演示。我用inSampleSize解码图像以减少内存消耗。我也尝试正确处理回收的视图。

我推荐开源仪器 通用图像加载器。它最初基于Fedor Vlasov的项目 LazyList 从那时起，它已经有了很大的改进。

• 多线程图像加载
• 可以广泛调整ImageLoader的配置（线程执行器，下载器，解码器，内存和光盘缓存，显示图像选项等）
• 在内存和/或设备的文件系统（或SD卡）上进行图像缓存的可能性
• 可以“监听”加载过程
• 可以使用单独的选项自定义每个显示图像调用
• 小工具支持
• Android 2.0+支持

多线程性能，Gilles Debunne的教程。

这是来自Android开发者博客。建议的代码使用：

• AsyncTasks。
• 坚硬，有限的尺寸， FIFO cache。
• 柔软，轻松 garbage collect-ed缓存。
• 一个 占位符  Drawable 当你下载。

更新：请注意，这个答案现在非常无效。垃圾收集器对SoftReference和WeakReference采取积极行动，因此此代码不适用于新应用程序。  （相反，尝试库像 通用图像加载器 在其他答案中建议。）

感谢James的代码，以及Bao-Long建议使用SoftReference。我在James的代码上实现了SoftReference的更改。不幸的是，SoftReferences导致我的图像垃圾收集过快。在我的情况下没有SoftReference的东西很好，因为我的列表大小有限，我的图像很小。

一年前有关于google群组的SoftReferences的讨论： 链接到线程。作为过早垃圾收集的解决方案，他们建议使用dalvik.system.VMRuntime.setMinimumHeapSize（）手动设置VM堆大小，这对我来说不是很有吸引力。

public DrawableManager() {
    drawableMap = new HashMap<String, SoftReference<Drawable>>();
}

public Drawable fetchDrawable(String urlString) {
    SoftReference<Drawable> drawableRef = drawableMap.get(urlString);
    if (drawableRef != null) {
        Drawable drawable = drawableRef.get();
        if (drawable != null)
            return drawable;
        // Reference has expired so remove the key from drawableMap
        drawableMap.remove(urlString);
    }

    if (Constants.LOGGING) Log.d(this.getClass().getSimpleName(), "image url:" + urlString);
    try {
        InputStream is = fetch(urlString);
        Drawable drawable = Drawable.createFromStream(is, "src");
        drawableRef = new SoftReference<Drawable>(drawable);
        drawableMap.put(urlString, drawableRef);
        if (Constants.LOGGING) Log.d(this.getClass().getSimpleName(), "got a thumbnail drawable: " + drawable.getBounds() + ", "
                + drawable.getIntrinsicHeight() + "," + drawable.getIntrinsicWidth() + ", "
                + drawable.getMinimumHeight() + "," + drawable.getMinimumWidth());
        return drawableRef.get();
    } catch (MalformedURLException e) {
        if (Constants.LOGGING) Log.e(this.getClass().getSimpleName(), "fetchDrawable failed", e);
        return null;
    } catch (IOException e) {
        if (Constants.LOGGING) Log.e(this.getClass().getSimpleName(), "fetchDrawable failed", e);
        return null;
    }
}

public void fetchDrawableOnThread(final String urlString, final ImageView imageView) {
    SoftReference<Drawable> drawableRef = drawableMap.get(urlString);
    if (drawableRef != null) {
        Drawable drawable = drawableRef.get();
        if (drawable != null) {
            imageView.setImageDrawable(drawableRef.get());
            return;
        }
        // Reference has expired so remove the key from drawableMap
        drawableMap.remove(urlString);
    }

    final Handler handler = new Handler() {
        @Override
        public void handleMessage(Message message) {
            imageView.setImageDrawable((Drawable) message.obj);
        }
    };

    Thread thread = new Thread() {
        @Override
        public void run() {
            //TODO : set imageView to a "pending" image
            Drawable drawable = fetchDrawable(urlString);
            Message message = handler.obtainMessage(1, drawable);
            handler.sendMessage(message);
        }
    };
    thread.start();
}

毕加索 

使用杰克沃顿的毕加索图书馆。 （一个完美的ImageLoading Library构成ActionBarSherlock的开发者）

适用于Android的强大图像下载和缓存库。

图像为Android应用程序添加了急需的上下文和视觉风格。 Picasso允许在您的应用程序中轻松加载图像 - 通常只需一行代码！

Picasso.with(context).load("http://i.imgur.com/DvpvklR.png").into(imageView);

Android上图像加载的许多常见缺陷由Picasso自动处理：

在适配器中处理ImageView回收和下载取消。 复杂的图像转换，内存使用最少。 自动内存和磁盘缓存。

毕加索杰克沃顿图书馆

滑行

Glide是一个快速高效的Android开源媒体管理框架，它将媒体解码，内存和磁盘缓存以及资源池包装成一个简单易用的界面。

Glide支持提取，解码和显示视频静止图像，图像和动画GIF。 Glide包含一个灵活的api，允许开发人员插入几乎任何网络堆栈。默认情况下，Glide使用基于HttpUrlConnection的自定义堆栈，但也包括插入Google的Volley项目或Square的OkHttp库的实用程序库。

Glide.with(this).load("http://goo.gl/h8qOq7").into(imageView);

Glide主要关注的是尽可能平滑和快速地滚动任何类型的图像列表，但Glide对于几乎任何需要获取，调整大小和显示远程图像的情况也很有效。

滑翔图像加载库

Fresco by Facebook 

Fresco是一个功能强大的系统，用于在Android应用程序中显示图像。

Fresco负责图像加载和显示，因此您不必这样做。它将从网络，本地存储或本地资源加载图像，并显示占位符，直到图像到达。它有两级缓存;一个在内存中，另一个在内部存储中。

Fresco Github

在Android 4.x及更低版本中，Fresco将图像放在Android内存的特殊区域。这可以让您的应用程序运行得更快 - 并且可以更少地遭遇可怕的OutOfMemoryError。

壁画文件

高性能加载器 - 在检查了这里建议的方法之后， 我用了 本的解决方案 有一些变化 -

1. 我意识到使用drawables比使用位图更快，所以我使用drawables代替

2. 使用SoftReference非常棒，但它会使缓存的图像被删除太频繁，所以我添加了一个包含图像引用的链接列表，防止图像被删除，直到它达到预定义的大小

3. 要打开InputStream，我使用java.net.URLConnection，它允许我使用Web缓存（您需要先设置响应缓存，但这是另一个故事）

我的代码：

import java.util.Map; 
import java.util.HashMap; 
import java.util.LinkedList; 
import java.util.Collections; 
import java.util.WeakHashMap; 
import java.lang.ref.SoftReference; 
import java.util.concurrent.Executors; 
import java.util.concurrent.ExecutorService; 
import android.graphics.drawable.Drawable;
import android.widget.ImageView;
import android.os.Handler;
import android.os.Message;
import java.io.InputStream;
import java.net.MalformedURLException; 
import java.io.IOException; 
import java.net.URL;
import java.net.URLConnection;

public class DrawableBackgroundDownloader {    

private final Map<String, SoftReference<Drawable>> mCache = new HashMap<String, SoftReference<Drawable>>();   
private final LinkedList <Drawable> mChacheController = new LinkedList <Drawable> ();
private ExecutorService mThreadPool;  
private final Map<ImageView, String> mImageViews = Collections.synchronizedMap(new WeakHashMap<ImageView, String>());  

public static int MAX_CACHE_SIZE = 80; 
public int THREAD_POOL_SIZE = 3;

/**
 * Constructor
 */
public DrawableBackgroundDownloader() {  
    mThreadPool = Executors.newFixedThreadPool(THREAD_POOL_SIZE);  
}  


/**
 * Clears all instance data and stops running threads
 */
public void Reset() {
    ExecutorService oldThreadPool = mThreadPool;
    mThreadPool = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
    oldThreadPool.shutdownNow();

    mChacheController.clear();
    mCache.clear();
    mImageViews.clear();
}  

public void loadDrawable(final String url, final ImageView imageView,Drawable placeholder) {  
    mImageViews.put(imageView, url);  
    Drawable drawable = getDrawableFromCache(url);  

    // check in UI thread, so no concurrency issues  
    if (drawable != null) {  
        //Log.d(null, "Item loaded from mCache: " + url);  
        imageView.setImageDrawable(drawable);  
    } else {  
        imageView.setImageDrawable(placeholder);  
        queueJob(url, imageView, placeholder);  
    }  
} 


private Drawable getDrawableFromCache(String url) {  
    if (mCache.containsKey(url)) {  
        return mCache.get(url).get();  
    }  

    return null;  
}

private synchronized void putDrawableInCache(String url,Drawable drawable) {  
    int chacheControllerSize = mChacheController.size();
    if (chacheControllerSize > MAX_CACHE_SIZE) 
        mChacheController.subList(0, MAX_CACHE_SIZE/2).clear();

    mChacheController.addLast(drawable);
    mCache.put(url, new SoftReference<Drawable>(drawable));

}  

private void queueJob(final String url, final ImageView imageView,final Drawable placeholder) {  
    /* Create handler in UI thread. */  
    final Handler handler = new Handler() {  
        @Override  
        public void handleMessage(Message msg) {  
            String tag = mImageViews.get(imageView);  
            if (tag != null && tag.equals(url)) {
                if (imageView.isShown())
                    if (msg.obj != null) {
                        imageView.setImageDrawable((Drawable) msg.obj);  
                    } else {  
                        imageView.setImageDrawable(placeholder);  
                        //Log.d(null, "fail " + url);  
                    } 
            }  
        }  
    };  

    mThreadPool.submit(new Runnable() {  
        @Override  
        public void run() {  
            final Drawable bmp = downloadDrawable(url);
            // if the view is not visible anymore, the image will be ready for next time in cache
            if (imageView.isShown())
            {
                Message message = Message.obtain();  
                message.obj = bmp;
                //Log.d(null, "Item downloaded: " + url);  

                handler.sendMessage(message);
            }
        }  
    });  
}  



private Drawable downloadDrawable(String url) {  
    try {  
        InputStream is = getInputStream(url);

        Drawable drawable = Drawable.createFromStream(is, url);
        putDrawableInCache(url,drawable);  
        return drawable;  

    } catch (MalformedURLException e) {  
        e.printStackTrace();  
    } catch (IOException e) {  
        e.printStackTrace();  
    }  

    return null;  
}  


private InputStream getInputStream(String urlString) throws MalformedURLException, IOException {
    URL url = new URL(urlString);
    URLConnection connection;
    connection = url.openConnection();
    connection.setUseCaches(true); 
    connection.connect();
    InputStream response = connection.getInputStream();

    return response;
}
}