import java.io.BufferedInputStream;  
    import java.io.ByteArrayOutputStream;  
    import java.io.InputStream;  
    import java.net.HttpURLConnection;  
    import java.net.URL;  
    import java.util.concurrent.ExecutorService;  
    import java.util.concurrent.Executors;  
      
    import android.graphics.Bitmap;  
    import android.graphics.BitmapFactory;  
    import android.os.Handler;  
    import android.os.Message;  
    import android.support.v4.util.LruCache;  
    import android.util.Log;  
    import android.widget.ImageView;  
      
    /* 
     * 使用Android新式LruCache缓存图片，基于线程池异步加载图片。  
     * 基本思路：开辟一个线程池下载网络图片，同时创建一个LruCache作为Android内存缓存混存图片。 
     * 上层应用传递过来一个URL要求从该URL下载图片时，首先检查LruCache中是否存在以该URL为索引的缓存图片， 
     * 若有，则直接从缓存中读出来返回给上层应用；若没有，此时再开辟线程下载，下载完成后将此bitmap埋入缓存。 
     * 备注：图片的url作为缓存图片时LruCache的 Key。 
     * LruCache在内存中的缓存模型为<K,V>。 
     */  
      
    public class AsyncImageLoader {  
      
        private ExecutorService pool;  
        private Handler handler;  
        private ImageLoadedListener listener;  
      
        private final int WHAT = 0xe001;  
      
        // 默认的线程池容量  
        private int DEFAULT_TASK_NUMBER = 10;  
      
        // 网络超时时间：30秒  
        private static int TIMEOUT = 30 * 1000;  
      
        private LruCache<String, Bitmap> mMemoryCache;  
        // 4MB缓存大小  
        private final int CACHE_SIZE = 4 * 1024 * 1024;  
      
        public AsyncImageLoader(int asyncTaskNumber) {  
            initialization(asyncTaskNumber);  
        }  
      
        public AsyncImageLoader() {  
            // 默认的构造函数初始化线程池容量为：TASK_NUMBER  
            initialization(DEFAULT_TASK_NUMBER);  
        }  
      
        // 初始化  
        private void initialization(int asyncTaskNumber) {  
            mMemoryCache = new LruCache<String, Bitmap>(CACHE_SIZE) {  
                @Override  
                protected int sizeOf(String key, Bitmap value) {  
                    return value.getRowBytes() * value.getHeight();  
                }  
            };  
      
            // 创建容量为 asyncTaskNumber 的线程池。  
            pool = Executors.newFixedThreadPool(asyncTaskNumber);  
      
            handler = new Handler() {  
                @Override  
                public void handleMessage(Message message) {  
                    switch (message.what) {  
                    case WHAT:  
                        listener.imageLoaded((Bitmap) message.obj);  
                    }  
                }  
            };  
        }  
      
          
        // 异步设置一个ImagView的Bitmap（该ImageView的Bitmap从网络加载）  
        // 该方法为public，作为该工具类的外部调用接口。  
        public void asyncSetImageBitmap(String url, final ImageView view) {  
            download(url, new ImageLoadedListener() {  
                @Override  
                public void imageLoaded(Bitmap bitmap) {  
                    view.setImageBitmap(bitmap);  
                }  
            });  
        }  
      
        // 异步的从一个URL下载一个Bitmap。  
        // 下载成功后，回调imageLoaded(Bitmap bitmap, String url)；  
        // 该方法为public，作为该工具类的外部调用接口。  
        public void download(String url, ImageLoadedListener listener) {  
            this.listener = listener;  
      
            // 首先从缓存中检查是否存在以url为key的bitmap。  
            // 若有，则直接从缓存中读取使用，不再使用线程重复加载。  
            Bitmap bmp = mMemoryCache.get(url);  
            if (bmp != null) {  
                Log.d("读取缓存", url + " 已经缓存，无须重复下载！");  
                sendResult(bmp);  
                return;  
            }  
      
            Thread t = new DownloadThread(url);  
            pool.execute(t);  
        }  
          
      
        // 开辟一个下载线程  
        private class DownloadThread extends Thread {  
      
            private String url;  
      
            public DownloadThread(String url) {  
                this.url = url;  
            }  
      
            @Override  
            public void run() {  
                Bitmap bmp = loadBitmapFromURL(url);  
      
                // 将新的bitmap埋入缓存  
                mMemoryCache.put(url, bmp);  
      
                sendResult(bmp);  
            }  
        }  
      
        // 发送消息通知：bitmap已经下载完成。  
        private void sendResult(Bitmap bitmap) {  
            Message message = handler.obtainMessage();  
            message.what = WHAT;  
            message.obj = bitmap;  
            handler.sendMessage(message);  
        }  
      
        // 回调函数  
        public interface ImageLoadedListener {  
            public void imageLoaded(Bitmap bitmap);  
        }  
      
        // 给定一个URL，从这个URL下载Bitmap  
        public static Bitmap loadBitmapFromURL(String url) {  
            if (!url.contains("http://")) {  
                url = "http://" + url;  
            }  
      
            Log.d("线程：" + Thread.currentThread().getId(), "开始下载: " + url);  
      
            Bitmap bmp = null;  
            try {  
                byte[] imageBytes = loadRawDataFromURL(url);  
                bmp = BitmapFactory.decodeByteArray(imageBytes, 0,  
                        imageBytes.length);  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
      
            return bmp;  
        }  
      
        // 给定一个URL，从这个URL下载原始数据块。  
        public static byte[] loadRawDataFromURL(String u) throws Exception {  
            URL url = new URL(u);  
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();  
            // 配置基础网络链接参数  
            conn.setConnectTimeout(TIMEOUT);  
            conn.setReadTimeout(TIMEOUT);  
      
            InputStream is = conn.getInputStream();  
            BufferedInputStream bis = new BufferedInputStream(is);  
      
            ByteArrayOutputStream baos = new ByteArrayOutputStream();  
      
            final int BUFFER_SIZE = 1024 * 5;  
            final int EOF = -1;  
      
            int c;  
            byte[] buf = new byte[BUFFER_SIZE];  
      
            while (true) {  
                c = bis.read(buf);  
                if (c == EOF)  
                    break;  
      
                baos.write(buf, 0, c);  
            }  
      
            conn.disconnect();  
            is.close();  
      
            byte[] data = baos.toByteArray();  
            baos.flush();  
      
            return data;  
        }  
    }