我已经在 stackoverflow 中阅读了关于延迟列表加载的几个主题，并且我正在尝试了解如何在 android 中处理不同的缓存级别。

如这里所述:

Lazy load of images in ListView

我用过

Multithreading For Performance ，Gilles Debunne 的教程。

例子。我对其进行了修改，以便以正确的方式工作并且还可以使用 1.6。这是代码:

/*
 * Copyright (C) 2010 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

public class ImageDownloader 
{

private static final String TAG = "ImageDownloader";

private static final int HARD_CACHE_CAPACITY = 40;
private static final int DELAY_BEFORE_PURGE = 10 * 1000; // in milliseconds

private final static ConcurrentHashMap<String, SoftReference<Bitmap>> sSoftBitmapCache = new ConcurrentHashMap<String, SoftReference<Bitmap>>(HARD_CACHE_CAPACITY / 2);

/* Download the specified image from the Internet and binds it to the provided ImageView. The
 * binding is immediate if the image is found in the cache and will be done asynchronously
 * otherwise. A null bitmap will be associated to the ImageView if an error occurs.
 *
 * @param url The URL of the image to download.
 * @param imageView The ImageView to bind the downloaded image to.
 */

public void download(String url, ImageView imageView) {

    Log.d(TAG, "download(String url, ImageView imageView)");

    resetPurgeTimer();

    Bitmap bitmap = getBitmapFromCache(url);

    if (bitmap == null) {

        Log.d(TAG, "(bitmap == null)");

        forceDownload(url, imageView);

    } else {

        Log.d(TAG, "(bitmap != null) ");

        cancelPotentialDownload(url, imageView);
        imageView.setImageBitmap(bitmap);
    }
}

/*
 * Same as download but the image is always downloaded and the cache is not used.
 * Kept private at the moment as its interest is not clear.
   private void forceDownload(String url, ImageView view) {
      forceDownload(url, view, null);
   }
 */

/**
 * Same as download but the image is always downloaded and the cache is not used.
 * Kept private at the moment as its interest is not clear.
 */
private void forceDownload(String url, ImageView imageView) {

    Log.d(TAG, "forceDownload(String url, ImageView imageView)");


    // State sanity: url is guaranteed to never be null in DownloadedDrawable and cache keys.
    if (url == null) {

        Log.d(TAG, "(url == null)");

        imageView.setImageDrawable(null);
        return;
    }
    Bitmap bitmap = null;
    BitmapDownloaderTask task = null;

    if (cancelPotentialDownload(url, imageView)) {

                Log.d(TAG, "(cancelPotentialDownload(url, imageView))");


                 task = new BitmapDownloaderTask(imageView);
                DownloadedDrawable downloadedDrawable = new DownloadedDrawable(task);
                imageView.setImageDrawable(downloadedDrawable);
                imageView.setMinimumHeight(156);
                task.execute(url);

    }
}

/**
 * Returns true if the current download has been canceled or if there was no download in
 * progress on this image view.
 * Returns false if the download in progress deals with the same url. The download is not
 * stopped in that case.
 */
private static boolean cancelPotentialDownload(String url, ImageView imageView) {

    Log.d(TAG, "---cancelPotentialDownload(String url, ImageView imageView)----)");


    BitmapDownloaderTask bitmapDownloaderTask = getBitmapDownloaderTask(imageView);

    if (bitmapDownloaderTask != null) {

        Log.d(TAG, "(bitmapDownloaderTask != null)");


        String bitmapUrl = bitmapDownloaderTask.url;

        if ((bitmapUrl == null) || (!bitmapUrl.equals(url))) {

            Log.d(TAG, "(((bitmapUrl == null) || (!bitmapUrl.equals(url)))");


            bitmapDownloaderTask.cancel(true);
        } else {

            Log.d(TAG, "The same URL is already being downloaded.");

            // The same URL is already being downloaded.
            return false;
        }
    }
    return true;
}

/**
 * @param imageView Any imageView
 * @return Retrieve the currently active download task (if any) associated with this imageView.
 * null if there is no such task.
 */
private static BitmapDownloaderTask getBitmapDownloaderTask(ImageView imageView) {

    Log.d(TAG, "getBitmapDownloaderTask(ImageView imageView)");


    if (imageView != null) {

        Log.d(TAG, "(imageView != null) )");


        Drawable drawable = imageView.getDrawable();

        if (drawable instanceof DownloadedDrawable) {

            Log.d(TAG, "(drawable instanceof DownloadedDrawable) ");


            DownloadedDrawable downloadedDrawable = (DownloadedDrawable)drawable;
            return downloadedDrawable.getBitmapDownloaderTask();
        }
    }
    return null;
}

Bitmap downloadBitmap(String stringUrl) {

    Log.d(TAG, "(downloadBitmap(String stringUrl)");


    URL url = null;
    HttpURLConnection connection = null;
    InputStream inputStream = null;

    try {
         url = new URL(stringUrl);
        connection = (HttpURLConnection) url.openConnection();
        connection.setUseCaches(true);
        inputStream = connection.getInputStream();

       return BitmapFactory.decodeStream(new FlushedInputStream(inputStream));
       /* 
        BitmapFactory.Options bfOptions=new BitmapFactory.Options();

        bfOptions.inDither=false;                     //Disable Dithering mode
        bfOptions.inPurgeable=true;                   //Tell to gc that whether it needs free memory, the Bitmap can be cleared
        bfOptions.inInputShareable=true;              //Which kind of reference will be used to recover the Bitmap data after being clear, when it will be used in the future
        bfOptions.inTempStorage=new byte[32 * 1024]; 


        Bitmap b=BitmapFactory.decodeStream(new FlushedInputStream(inputStream), null,bfOptions );

        return b;
       */ 

    } catch (IOException e) {
        //getRequest.abort();
        Log.w(TAG, "I/O error while retrieving bitmap from " + url, e);
    } catch (IllegalStateException e) {
       // getRequest.abort();
        Log.w(TAG, "Incorrect URL: " + url);
    } catch (Exception e) {
        //getRequest.abort();
        Log.w(TAG, "Error while retrieving bitmap from " + url, e);
    } finally {
        if (connection != null) {
            connection.disconnect();
        }
    }


    return null;
}

/*
 * An InputStream that skips the exact number of bytes provided, unless it reaches EOF.
 */
static class FlushedInputStream extends FilterInputStream {



    public FlushedInputStream(InputStream inputStream) {
        super(inputStream);
    }

    @Override
    public long skip(long n) throws IOException {
        long totalBytesSkipped = 0L;
        while (totalBytesSkipped < n) {
            long bytesSkipped = in.skip(n - totalBytesSkipped);
            if (bytesSkipped == 0L) {
                int b = read();
                if (b < 0) {
                    break;  // we reached EOF
                } else {
                    bytesSkipped = 1; // we read one byte
                }
            }
            totalBytesSkipped += bytesSkipped;
        }
        return totalBytesSkipped;
    }
}

/**
 * The actual AsyncTask that will asynchronously download the image.
 */
class BitmapDownloaderTask extends AsyncTask<String, Void, Bitmap> {

    private String url;

    private final WeakReference<ImageView> imageViewReference;

    public BitmapDownloaderTask(ImageView imageView) {

        Log.w(TAG, "BitmapDownloaderTask(ImageView imageView)");

        imageViewReference = new WeakReference<ImageView>(imageView);
    }

    /**
     * Actual download method.
     */
    @Override
    protected Bitmap doInBackground(String... params) {

        Log.w(TAG, "doInBackground");


        url = params[0];
        return downloadBitmap(url);
    }

    /**
     * Once the image is downloaded, associates it to the imageView
     */
    @Override
    protected void onPostExecute(Bitmap bitmap) {

        Log.w(TAG, "onPostExecute");


        if (isCancelled()) {
            bitmap = null;
        }

        addBitmapToCache(url, bitmap);

        if (imageViewReference != null) {

            Log.w(TAG, "(imageViewReference != null)");


            ImageView imageView = imageViewReference.get();

            BitmapDownloaderTask bitmapDownloaderTask = getBitmapDownloaderTask(imageView);

            // Change bitmap only if this process is still associated with it
            // Or if we don't use any bitmap to task association (NO_DOWNLOADED_DRAWABLE mode)

            if ((this == bitmapDownloaderTask)) {

                Log.w(TAG, " if ((this == bitmapDownloaderTask)");


                imageView.setImageBitmap(bitmap);
            }
        }
    }
}


/**
 * A fake Drawable that will be attached to the imageView while the download is in progress.
 *
 * <p>Contains a reference to the actual download task, so that a download task can be stopped
 * if a new binding is required, and makes sure that only the last started download process can
 * bind its result, independently of the download finish order.</p>
 */
static class DownloadedDrawable extends ColorDrawable {

    private final WeakReference<BitmapDownloaderTask> bitmapDownloaderTaskReference;

    public DownloadedDrawable(BitmapDownloaderTask bitmapDownloaderTask) {
        super(Color.BLACK);

        Log.w(TAG, "DownloadedDrawable(BitmapDownloaderTask bitmapDownloaderTask) ");


        bitmapDownloaderTaskReference = new WeakReference<BitmapDownloaderTask>(bitmapDownloaderTask);
    }

    public BitmapDownloaderTask getBitmapDownloaderTask() {

        Log.w(TAG, "BitmapDownloaderTask getBitmapDownloaderTask() ");


        return bitmapDownloaderTaskReference.get();
    }
}

/*
public void setMode(Mode mode) {
    this.mode = mode;
    clearCache();
}
*/

/*
 * Cache-related fields and methods.
 * 
 * We use a hard and a soft cache. A soft reference cache is too aggressively cleared by the
 * Garbage Collector.
 */

// Hard cache, with a fixed maximum capacity and a life duration
private final HashMap<String, Bitmap> sHardBitmapCache = new LinkedHashMap<String, Bitmap>(HARD_CACHE_CAPACITY / 2, 0.75f, true)

   // private final HashMap<String, Bitmap> sHardBitmapCache = new LinkedHashMap<String, Bitmap>() 
{
      // private static final long serialVersionUID = -695136752926135717L;

    @Override
    protected boolean removeEldestEntry(LinkedHashMap.Entry<String, Bitmap> eldest) {

        Log.w(TAG, "removeEldestEntry(LinkedHashMap.Entry<String, Bitmap> eldest) ");

        Log.w(TAG, "size()  : " + size());
        Log.w(TAG, "HARD_CACHE_CAPACITY  : " + HARD_CACHE_CAPACITY);

        if (size() > HARD_CACHE_CAPACITY) {

             Log.w(TAG, "(size() > HARD_CACHE_CAPACITY) ");
             Log.e(TAG, "sSoftBitmapCache --> sSoftBitmapCache.put ");

            // Entries push-out of hard reference cache are transferred to soft reference cache
            sSoftBitmapCache.put(eldest.getKey(), new SoftReference<Bitmap>(eldest.getValue()));

            return true;

        } else
            return false;
    }
};

//HARD_CACHE_CAPACITY / 2
// Soft cache for bitmaps kicked out of hard cache
   // private final static ConcurrentHashMap<String, SoftReference<Bitmap>>     sSoftBitmapCache = new ConcurrentHashMap<String, SoftReference<Bitmap>>();

private final Handler purgeHandler = new Handler();

private final Runnable purger = new Runnable() {
    public void run() {
         Log.e(TAG, "purger run");


       // clearCache();
    }
};

/**
 * Adds this bitmap to the cache.
 * @param bitmap The newly downloaded bitmap.
 */
private void addBitmapToCache(String url, Bitmap bitmap) {

    Log.w(TAG, "--------addBitmapToCache-----------");


    if (bitmap != null) {

        Log.w(TAG, "(bitmap != null) ");


        synchronized (sHardBitmapCache) {

             //final Bitmap tryData = sHardBitmapCache.get(url);

            //    if (tryData != null) {
            //      sHardBitmapCache.remove(url);
            //    }

            Log.w(TAG, " sHardBitmapCache.put(url, bitmap);");

            sHardBitmapCache.put(url, bitmap);
        }
    }
}

/**
 * @param url The URL of the image that will be retrieved from the cache.
 * @return The cached bitmap or null if it was not found.
 */
private Bitmap getBitmapFromCache(String url) {

    Log.e(TAG, " --------getBitmapFromCache(String url)----------------");


    // First try the hard reference cache
    synchronized (sHardBitmapCache) {

        final Bitmap bitmap = sHardBitmapCache.get(url);

        if (bitmap != null) {

            Log.e(TAG, " getBitmapFromCache ---> Bitmap found in Hard cache!!!!!");

            // Bitmap found in hard cache
            // Move element to first position, so that it is removed last

            sHardBitmapCache.remove(url);
            sHardBitmapCache.put(url, bitmap);

            return bitmap;

        }else{

            Log.e(TAG, " getBitmapFromCache ---> Bitmap not found in Hard cache");


        }
    }

    // Then try the soft reference cache
    SoftReference<Bitmap> bitmapReference = sSoftBitmapCache.get(url);

    if (bitmapReference != null) {

        Log.e(TAG, " getBitmapFromCache ---> bitmapReference found in SoftReference cache!");


        final Bitmap bitmap = bitmapReference.get();

        if (bitmap != null) {

            Log.e(TAG, "Bitmap found in SoftReference cache!!!!!!!");


            // Bitmap found in soft cache
            return bitmap;


        } else {
            Log.e(TAG, "oooooooooooooooooooo --> Soft reference has been Garbage Collected");

            // Soft reference has been Garbage Collected
            sSoftBitmapCache.remove(url);
        }
    }

    return null;
}

/**
 * Clears the image cache used internally to improve performance. Note that for memory
 * efficiency reasons, the cache will automatically be cleared after a certain inactivity delay.
 */
public void clearCache() {

    Log.e(TAG, "----------------clearCache() ------------------");

    synchronized (sHardBitmapCache) {
        //sHardBitmapCache.clear();
    }
    //sSoftBitmapCache.clear();

    sHardBitmapCache.clear();
    sSoftBitmapCache.clear();
}

/**
 * Allow a new delay before the automatic cache clear is done.
 */
private void resetPurgeTimer() {
    purgeHandler.removeCallbacks(purger);
    purgeHandler.postDelayed(purger, DELAY_BEFORE_PURGE);
}

我完全理解这个例子背后的逻辑，但是我很困惑为什么它不能正常工作。

我们有两级缓存:硬缓存和软引用缓存。我们将位图保存在硬缓存中，然后在填充时保存在 SoftReference 中并重新排序硬缓存..

然后我关闭应用程序，关闭互联网并重新启动它。在构造函数中，我们调用 resetPurgeTimer() 来清除缓存，因此缓存中没有任何内容。为了避免这种情况，我对该行进行了注释，以免清除缓存。我重新启动了我的应用程序，我可以看到 SoftReference 缓存中存在 6-7 个图像(根据 LogCat)。

我知道 SoftReference 缓存在调用 GC 时可能会变空，但即使在关闭应用程序或禁用 wifi 之前它也几乎是空的......SoftReferences 有一个众所周知的错误，即使内存不足也会被垃圾收集..

这个广泛使用的例子有什么问题吗？

提前致谢

安德烈亚斯

最佳答案

是的，在 Android 3.0 及更高版本中，您不能对位图使用弱引用或软引用。 JVM 会主动收集它们。相反，您应该使用 LRUCache(在支持库中)来缓存它们。我还建议将最大缓存的大小设置为最大堆大小的一部分(例如 1/6)。

关于android - Lazy List 上的位图缓存(SoftReference，Hard)似乎无法正常工作 - Android，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/7635224/