Android实现图片缓存与异步加载

ImageManager2这个类具有异步从网络下载图片，从sd读取本地图片，内存缓存，硬盘缓存，图片使用动画渐现等功能，已经将其应用在包含大量图片的应用中一年多，没有出现oom。

Android程序常常会内存溢出，网上也有很多解决方案，如软引用，手动调用recycle等等。但经过我们实践发现这些方案，都没能起到很好的效果，我们的应用依然会出现很多oom，尤其我们的应用包含大量的图片。android3.0之后软引用基本已经失效，因为虚拟机只要碰到软引用就回收，所以带不来任何性能的提升。

我这里的解决方案是HandlerThread(异步加载)+LruCache(内存缓存)+DiskLruCache(硬盘缓存)。

作为程序员，我也不多说，直接和大家共享我的代码，用代码交流更方便些。

package com.example.util;

import java.io.File;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.util.EntityUtils;

import android.app.ActivityManager;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.ColorDrawable;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.TransitionDrawable;
import android.media.ThumbnailUtils;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import android.support.v4.util.LruCache;
import android.widget.ImageView;

import com.example.MyApplication;

/**
* 图片加载类
*
* @author 月月鸟
*/
public class ImageManager2 {

private static ImageManager2 imageManager;
 public LruCache<String, Bitmap> mMemoryCache;
 private static final int DISK_CACHE_SIZE = 1024 * 1024 * 20; // 10MB
 private static final String DISK_CACHE_SUBDIR = "thumbnails";
 public DiskLruCache mDiskCache;
 private static MyApplication myapp;

/** 图片加载队列，后进先出 */
 private Stack<ImageRef> mImageQueue = new Stack<ImageRef>();

/** 图片请求队列，先进先出，用于存放已发送的请求。 */
 private Queue<ImageRef> mRequestQueue = new LinkedList<ImageRef>();

/** 图片加载线程消息处理器 */
 private Handler mImageLoaderHandler;

/** 图片加载线程是否就绪 */
 private boolean mImageLoaderIdle = true;

/** 请求图片 */
 private static final int MSG_REQUEST = 1;
 /** 图片加载完成 */
 private static final int MSG_REPLY = 2;
 /** 中止图片加载线程 */
 private static final int MSG_STOP = 3;
 /** 如果图片是从网络加载，则应用渐显动画，如果从缓存读出则不应用动画 */
 private boolean isFromNet = true;

/**
  * 获取单例，只能在UI线程中使用。
  *
  * @param context
  * @return
  */
 public static ImageManager2 from(Context context) {

// 如果不在ui线程中，则抛出异常
   if (Looper.myLooper() != Looper.getMainLooper()) {
     throw new RuntimeException("Cannot instantiate outside UI thread.");
   }

if (myapp == null) {
     myapp = (MyApplication) context.getApplicationContext();
   }

if (imageManager == null) {
     imageManager = new ImageManager2(myapp);
   }

return imageManager;
 }

/**
  * 私有构造函数，保证单例模式
  *
  * @param context
  */
 private ImageManager2(Context context) {
   int memClass = ((ActivityManager) context
       .getSystemService(Context.ACTIVITY_SERVICE)).getMemoryClass();
   memClass = memClass > 32 ? 32 : memClass;
   // 使用可用内存的1/8作为图片缓存
   final int cacheSize = 1024 * 1024 * memClass / 8;

mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {

protected int sizeOf(String key, Bitmap bitmap) {
       return bitmap.getRowBytes() * bitmap.getHeight();
     }

};

File cacheDir = DiskLruCache
       .getDiskCacheDir(context, DISK_CACHE_SUBDIR);
   mDiskCache = DiskLruCache.openCache(context, cacheDir, DISK_CACHE_SIZE);

}

/**
  * 存放图片信息
  */
 class ImageRef {

/** 图片对应ImageView控件 */
   ImageView imageView;
   /** 图片URL地址 */
   String url;
   /** 图片缓存路径 */
   String filePath;
   /** 默认图资源ID */
   int resId;
   int width = 0;
   int height = 0;

/**
    * 构造函数
    *
    * @param imageView
    * @param url
    * @param resId
    * @param filePath
    */
   ImageRef(ImageView imageView, String url, String filePath, int resId) {
     this.imageView = imageView;
     this.url = url;
     this.filePath = filePath;
     this.resId = resId;
   }

ImageRef(ImageView imageView, String url, String filePath, int resId,
       int width, int height) {
     this.imageView = imageView;
     this.url = url;
     this.filePath = filePath;
     this.resId = resId;
     this.width = width;
     this.height = height;
   }

}

/**
  * 显示图片
  *
  * @param imageView
  * @param url
  * @param resId
  */
 public void displayImage(ImageView imageView, String url, int resId) {
   if (imageView == null) {
     return;
   }
   if (imageView.getTag() != null
       && imageView.getTag().toString().equals(url)) {
     return;
   }
   if (resId >= 0) {
     if (imageView.getBackground() == null) {
       imageView.setBackgroundResource(resId);
     }
     imageView.setImageDrawable(null);

}
   if (url == null || url.equals("")) {
     return;
   }

// 添加url tag
   imageView.setTag(url);

// 读取map缓存
   Bitmap bitmap = mMemoryCache.get(url);
   if (bitmap != null) {
     setImageBitmap(imageView, bitmap, false);
     return;
   }

// 生成文件名
   String filePath = urlToFilePath(url);
   if (filePath == null) {
     return;
   }

queueImage(new ImageRef(imageView, url, filePath, resId));
 }

/**
  * 显示图片固定大小图片的缩略图，一般用于显示列表的图片，可以大大减小内存使用
  *
  * @param imageView 加载图片的控件
  * @param url 加载地址
  * @param resId 默认图片
  * @param width 指定宽度
  * @param height 指定高度
  */
 public void displayImage(ImageView imageView, String url, int resId,
     int width, int height) {
   if (imageView == null) {
     return;
   }
   if (resId >= 0) {

if (imageView.getBackground() == null) {
       imageView.setBackgroundResource(resId);
     }
     imageView.setImageDrawable(null);

}
   if (url == null || url.equals("")) {
     return;
   }

// 添加url tag
   imageView.setTag(url);
   // 读取map缓存
   Bitmap bitmap = mMemoryCache.get(url + width + height);
   if (bitmap != null) {
     setImageBitmap(imageView, bitmap, false);
     return;
   }

// 生成文件名
   String filePath = urlToFilePath(url);
   if (filePath == null) {
     return;
   }

queueImage(new ImageRef(imageView, url, filePath, resId, width, height));
 }

/**
  * 入队，后进先出
  *
  * @param imageRef
  */
 public void queueImage(ImageRef imageRef) {

// 删除已有ImageView
   Iterator<ImageRef> iterator = mImageQueue.iterator();
   while (iterator.hasNext()) {
     if (iterator.next().imageView == imageRef.imageView) {
       iterator.remove();
     }
   }

// 添加请求
   mImageQueue.push(imageRef);
   sendRequest();
 }

/**
  * 发送请求
  */
 private void sendRequest() {

// 开启图片加载线程
   if (mImageLoaderHandler == null) {
     HandlerThread imageLoader = new HandlerThread("image_loader");
     imageLoader.start();
     mImageLoaderHandler = new ImageLoaderHandler(
         imageLoader.getLooper());
   }

// 发送请求
   if (mImageLoaderIdle && mImageQueue.size() > 0) {
     ImageRef imageRef = mImageQueue.pop();
     Message message = mImageLoaderHandler.obtainMessage(MSG_REQUEST,
         imageRef);
     mImageLoaderHandler.sendMessage(message);
     mImageLoaderIdle = false;
     mRequestQueue.add(imageRef);
   }
 }

/**
  * 图片加载线程
  */
 class ImageLoaderHandler extends Handler {

public ImageLoaderHandler(Looper looper) {
     super(looper);
   }

public void handleMessage(Message msg) {
     if (msg == null)
       return;

switch (msg.what) {

case MSG_REQUEST: // 收到请求
       Bitmap bitmap = null;
       Bitmap tBitmap = null;
       if (msg.obj != null && msg.obj instanceof ImageRef) {

ImageRef imageRef = (ImageRef) msg.obj;
         String url = imageRef.url;
         if (url == null)
           return;
         // 如果本地url即读取sd相册图片，则直接读取，不用经过DiskCache
         if (url.toLowerCase().contains("dcim")) {

tBitmap = null;
           BitmapFactory.Options opt = new BitmapFactory.Options();
           opt.inSampleSize = 1;
           opt.inJustDecodeBounds = true;
           BitmapFactory.decodeFile(url, opt);
           int bitmapSize = opt.outHeight * opt.outWidth * 4;
           opt.inSampleSize = bitmapSize / (1000 * 2000);
           opt.inJustDecodeBounds = false;
           tBitmap = BitmapFactory.decodeFile(url, opt);
           if (imageRef.width != 0 && imageRef.height != 0) {
             bitmap = ThumbnailUtils.extractThumbnail(tBitmap,
                 imageRef.width, imageRef.height,
                 ThumbnailUtils.OPTIONS_RECYCLE_INPUT);
             isFromNet = true;
           } else {
             bitmap = tBitmap;
             tBitmap = null;
           }

} else
           bitmap = mDiskCache.get(url);

if (bitmap != null) {
           // ToolUtil.log("从disk缓存读取");
           // 写入map缓存
           if (imageRef.width != 0 && imageRef.height != 0) {
             if (mMemoryCache.get(url + imageRef.width
                 + imageRef.height) == null)
               mMemoryCache.put(url + imageRef.width
                   + imageRef.height, bitmap);
           } else {
             if (mMemoryCache.get(url) == null)
               mMemoryCache.put(url, bitmap);
           }

} else {
           try {
             byte[] data = loadByteArrayFromNetwork(url);

if (data != null) {

BitmapFactory.Options opt = new BitmapFactory.Options();
               opt.inSampleSize = 1;

opt.inJustDecodeBounds = true;
               BitmapFactory.decodeByteArray(data, 0,
                   data.length, opt);
               int bitmapSize = opt.outHeight * opt.outWidth
                   * 4;// pixels*3 if it's RGB and pixels*4
                     // if it's ARGB
               if (bitmapSize > 1000 * 1200)
                 opt.inSampleSize = 2;
               opt.inJustDecodeBounds = false;
               tBitmap = BitmapFactory.decodeByteArray(data,
                   0, data.length, opt);
               if (imageRef.width != 0 && imageRef.height != 0) {
                 bitmap = ThumbnailUtils
                     .extractThumbnail(
                         tBitmap,
                         imageRef.width,
                         imageRef.height,
                         ThumbnailUtils.OPTIONS_RECYCLE_INPUT);
               } else {
                 bitmap = tBitmap;
                 tBitmap = null;
               }

if (bitmap != null && url != null) {
                 // 写入SD卡
                 if (imageRef.width != 0
                     && imageRef.height != 0) {
                   mDiskCache.put(url + imageRef.width
                       + imageRef.height, bitmap);
                   mMemoryCache.put(url + imageRef.width
                       + imageRef.height, bitmap);
                 } else {
                   mDiskCache.put(url, bitmap);
                   mMemoryCache.put(url, bitmap);
                 }
                 isFromNet = true;
               }
             }
           } catch (OutOfMemoryError e) {
           }

}

}

if (mImageManagerHandler != null) {
         Message message = mImageManagerHandler.obtainMessage(
             MSG_REPLY, bitmap);
         mImageManagerHandler.sendMessage(message);
       }
       break;

case MSG_STOP: // 收到终止指令
       Looper.myLooper().quit();
       break;

}
   }
 }

/** UI线程消息处理器 */
 private Handler mImageManagerHandler = new Handler() {

@Override
   public void handleMessage(Message msg) {
     if (msg != null) {
       switch (msg.what) {

case MSG_REPLY: // 收到应答

do {
           ImageRef imageRef = mRequestQueue.remove();

if (imageRef == null)
             break;

if (imageRef.imageView == null
               || imageRef.imageView.getTag() == null
               || imageRef.url == null)
             break;

if (!(msg.obj instanceof Bitmap) || msg.obj == null) {
             break;
           }
           Bitmap bitmap = (Bitmap) msg.obj;

// 非同一ImageView
           if (!(imageRef.url).equals((String) imageRef.imageView
               .getTag())) {
             break;
           }

setImageBitmap(imageRef.imageView, bitmap, isFromNet);
           isFromNet = false;

} while (false);

break;
       }
     }
     // 设置闲置标志
     mImageLoaderIdle = true;

// 若服务未关闭，则发送下一个请求。
     if (mImageLoaderHandler != null) {
       sendRequest();
     }
   }
 };

/**
  * 添加图片显示渐现动画
  *
  */
 private void setImageBitmap(ImageView imageView, Bitmap bitmap,
     boolean isTran) {
   if (isTran) {
     final TransitionDrawable td = new TransitionDrawable(
         new Drawable[] {
             new ColorDrawable(android.R.color.transparent),
             new BitmapDrawable(bitmap) });
     td.setCrossFadeEnabled(true);
     imageView.setImageDrawable(td);
     td.startTransition(300);
   } else {
     imageView.setImageBitmap(bitmap);
   }
 }

/**
  * 从网络获取图片字节数组
  *
  * @param url
  * @return
  */
 private byte[] loadByteArrayFromNetwork(String url) {

try {

HttpGet method = new HttpGet(url);
     HttpResponse response = myapp.getHttpClient().execute(method);
     HttpEntity entity = response.getEntity();
     return EntityUtils.toByteArray(entity);

} catch (Exception e) {
     return null;
   }

}

/**
  * 根据url生成缓存文件完整路径名
  *
  * @param url
  * @return
  */
 public String urlToFilePath(String url) {

// 扩展名位置
   int index = url.lastIndexOf('.');
   if (index == -1) {
     return null;
   }

StringBuilder filePath = new StringBuilder();

// 图片存取路径
   filePath.append(myapp.getCacheDir().toString()).append('/');

// 图片文件名
   filePath.append(MD5.Md5(url)).append(url.substring(index));

return filePath.toString();
 }

/**
  * Activity#onStop后，ListView不会有残余请求。
  */
 public void stop() {

// 清空请求队列
   mImageQueue.clear();

}

}

这里就是给出了异步加载、内存缓存和硬盘缓存的解决方案，希望对大家的学习有所帮助。