Android ListView异步加载图片优化

废话不多说，异步请求多线程。

优化：

1.线程池  2.缓存到内存  3.缓存到SD卡  4.并发下防止重复请求（少数情况下）

主要用到 ExecutorService、SoftReference<Bitmap>、Future<SoftReference<Bitmap>>(防止重复线程请求)、ConcurrentHashMap<String, Future<SoftReference<Bitmap>>>()

package com.cntomorrow.tboing.imageloader;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.ref.SoftReference;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

import android.annotation.SuppressLint;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.widget.ImageView;

import com.tby.tboing.http.HttpRequestService;

public class AsyncBufferImageLoader {
	private final static String LOG_TAG= "ImageLoader";
	private final ConcurrentHashMap<String, Future<SoftReference<Bitmap>>> imageCache = new ConcurrentHashMap<String, Future<SoftReference<Bitmap>>>();
	//还是根据手机配置来吧
	private ExecutorService executors = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() + 3);
	@SuppressLint("SdCardPath")
	static final private String DIR = "/mnt/sdcard/Demo01/";
	
	public AsyncBufferImageLoader() {
	}
	
	/**
	 * <p> 加载图片</p>    
	 * @param imageView
	 * @param imageURL
	 * @param imageCallBack
	 * @param externalLoad 是否允许从SD卡或服务器获取图片
	 * @return <br><br>
	 * author tboing<BR>
	 * date 2013-4-1<br>
	 * remark <br>
	 */
	public Bitmap loadBitmap(final ImageView imageView, final String imageURL,
			final ImageCallBack imageCallBack, boolean externalLoad) {
		Handler handler = new Handler(){

			@Override
			public void handleMessage(Message msg) {
				Log.v(LOG_TAG, "从外部拿到了数据！");
				imageCallBack.imageLoad(imageView, (Bitmap)msg.obj, imageURL);
				super.handleMessage(msg);
			}
			
		};
		Future<SoftReference<Bitmap>> f = imageCache.get(imageURL);
		Bitmap bitmap = null;
		if (f != null) {
			Log.v(LOG_TAG, "缓存中有值，从缓存中取！");
			SoftReference<Bitmap> reference;
			try {
				if (f.isDone()) { // 如果结果已经返回则直接取，不会阻塞
					reference = f.get();
					bitmap = reference.get();
					if (bitmap != null) {
						Log.v(LOG_TAG, "缓存中取成功！");
						return bitmap;
					}
					Log.v(LOG_TAG, "缓存中取失败,将从SD卡或者服务器获取！");
					imageCache.remove(imageURL, f);
					// 如果弱引用失效则需要重新去请求
				} else {
					Log.v(LOG_TAG, "已经有线程请求图片，但未完成，请稍后！----------------------");
				}
			} catch (InterruptedException e) {

			} catch (ExecutionException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		if(!externalLoad) return null;
		executors.execute(new RequestImage(imageURL, handler));
		return null;
	}
	private class RequestImage implements Runnable {
		private String imageURL;
		private Handler handler;
		public RequestImage(String imageURL, Handler handler) {
			this.imageURL = imageURL;
			this.handler = handler;
		}
		@Override
		public void run() {
			Future<SoftReference<Bitmap>> f = null;
			Bitmap bitmap = null;
			//如果不需要从SD卡或者NET请求
			FutureTask<SoftReference<Bitmap>> ft = new FutureTask<SoftReference<Bitmap>>(
					new Callable<SoftReference<Bitmap>>() {

						@Override
						public SoftReference<Bitmap> call() throws Exception {
							Bitmap bitmap = readFromSDCard(imageURL); //从SD卡中获取
							if (bitmap == null) {
								Log.v(LOG_TAG, "SD卡中没取着！");
								// 如果不在内存缓存中，也不在本地（被jvm回收掉），则开启线程下载图片
								HttpRequestService httpRequest = new HttpRequestService();
								try {
									bitmap = httpRequest.requestBitmap(imageURL);
									Thread.sleep(1000);
									if (bitmap != null) {
										writeToSDCard(imageURL, bitmap);	//写入SD卡
									}
								} catch (IOException e1) {
									// TODO Auto-generated catch block
									e1.printStackTrace();
								}
							}
							return new SoftReference<Bitmap>(bitmap);
						}

					});
			//防止并发覆盖
			f = imageCache.putIfAbsent(imageURL, ft);
			if (f == null) {
				f = ft;
				ft.run();
			} else {
				Log.v(LOG_TAG, "其他线程正在请求！--------------------");
			}
			try {
				bitmap = f.get().get();
			} catch (Exception e) {
				imageCache.remove(imageURL, ft);
				e.printStackTrace();
			}
			sendMessage(bitmap);
		}
		
		private void sendMessage(Bitmap bitmap) {
			Message msg = handler.obtainMessage(0, bitmap);
			handler.sendMessage(msg);
			
		}
		
	}
	
	private Bitmap readFromSDCard(String imageURL) {
		String bitmapName = imageURL
				.substring(imageURL.lastIndexOf("/") + 1);
		File cacheDir = new File(DIR);
		File[] cacheFiles = cacheDir.listFiles();
		if(cacheFiles != null) {
			int i = 0;
			for (; i < cacheFiles.length; i++) {
				if (bitmapName.equals(cacheFiles[i].getName())) {
					break;
				}
			}

			if (i < cacheFiles.length) {
				return BitmapFactory.decodeFile(DIR + bitmapName);
			}
		}
		return null;
	}
	private void writeToSDCard(String imageURL, Bitmap bitmap) {
		File dir = new File(DIR);
		if (!dir.exists()) {
			dir.mkdirs();
		}

		File bitmapFile = new File(DIR
				+ imageURL.substring(imageURL.lastIndexOf("/") + 1));
		if (!bitmapFile.exists()) {
			try {
				bitmapFile.createNewFile();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		FileOutputStream fos;
		try {
			fos = new FileOutputStream(bitmapFile);
			bitmap.compress(Bitmap.CompressFormat.JPEG, 100, fos);
			fos.close();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	/**
	 * 回调接口
	 * 
	 * @author onerain
	 * 
	 */
	public interface ImageCallBack {
		public void imageLoad(ImageView imageView, Bitmap bitmap, String url);
	}
	
	public void shutdown() {
		if(executors != null) {
			executors.shutdown();
			executors = null;
		}
		imageCache.clear();
	}

}

其实如果说不存在重复图片也就不存在重复请求问题，这里是根据URL地址来判断图片的唯一性