AsyncImageLoader升级版,多线程异步图片加载器

2019独角兽企业重金招聘Python工程师标准>>>

原版程序出处未知，不知道是谁写的了，我在原有的基础上现在做一些改进优化

1.增加线程池功能，限制通知下载的线程数，

但是还有一些缺陷，
1.缓存的清理，大量图片之后的缓存策略，比如缓存太多之后，清理一些使用次数比较少的缓存图片
2.对于同一张图片，如果还没存在图片，那么在同一时间可以开启很多个对这张图片的下载任务，此处可以继续优化，后面有时间了再做了

public class AsyncImageLoader {
    private static final String TAG = "AsyncImageLoader";
    private ThreadPoolExecutor mPoolExecutor;
    private HashMap<String, SoftReference<Drawable>> imageCache;
    private Handler mMainThreadHandler;

    /**
     * 创建一个异步图片加载器，默认最大5个工作线程，最大等待队列20
     */
    public AsyncImageLoader() {
        this(5, 20);
    }

    /**
     * 创建一个异步图片加载器，当等待下载的图片超过设置的最大等待数量之后，会从等待队列中放弃一个最早加入队列的任务
     * 
     * @param maxPoolSize 最大工作线程数
     * @param queueSize 最大等待数
     */
    public AsyncImageLoader(int maxPoolSize, int queueSize) {
        this(2, maxPoolSize, 3, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(queueSize),
                new ThreadPoolExecutor.DiscardOldestPolicy());
    }

    /**
     * 自定义线程池的加载器,请参考:{@link ThreadPoolExecutor}
     * 
     * @param corePoolSize
     * @param maximumPoolSize
     * @param keepAliveTime
     * @param unit
     * @param workQueue
     * @param handler
     */
    public AsyncImageLoader(int corePoolSize, int maximumPoolSize, long keepAliveTime,
            TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) {
        imageCache = new HashMap<String, SoftReference<Drawable>>();
        mPoolExecutor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit,
                workQueue, handler);
        mMainThreadHandler = new Handler(Looper.getMainLooper());
    }

    /**
     * 异步加载一张图片
     * 
     * @param imageUrl
     * @param imageCallback
     */
    public void loadDrawable(final String imageUrl, final ImageCallback imageCallback) {
        if (imageCache.containsKey(imageUrl)) {
            SoftReference<Drawable> softReference = imageCache.get(imageUrl);
            Drawable drawable = softReference.get();
            if (drawable != null) {
                LogUtils.d(TAG, "load image from cache url:" + imageUrl);
                imageCallback.onLoaded(drawable);
                return;
            }
        }
        LoadImageTask task = new LoadImageTask(imageUrl, this, mMainThreadHandler, imageCallback);
        mPoolExecutor.execute(task);
    }

    /**
     * 停止线程池运行，停止之后，将不能在继续调用 {@link #loadDrawable(String, ImageCallback)}
     */
    public void shutdown() {
        mPoolExecutor.shutdown();
        imageCache.clear();
    }

    private void cache(String url, Drawable drawable) {
        imageCache.put(url, new SoftReference<Drawable>(drawable));
    }

    /**
     * 下载任务
     * 
     */
    private static final class LoadImageTask implements Runnable {

        private Handler mHandler;
        private ImageCallback mCallback;
        private AsyncImageLoader mLoader;
        private String mPath;

        /**
         * @param imgPath 要下载的图片地址
         * @param loader 图片加载器
         * @param handler 主线程Handler
         * @param imageCallback 图片加载回调
         */
        public LoadImageTask(String imgPath, AsyncImageLoader loader, Handler handler,
                ImageCallback imageCallback) {
            LogUtils.d(TAG, "start a task for load image:" + imgPath);
            this.mHandler = handler;
            this.mPath = imgPath;
            this.mLoader = loader;
            this.mCallback = imageCallback;
        }

        @Override
        public void run() {
            URL url;
            InputStream is = null;
            try {
                url = new URL(mPath);
                URLConnection conn = url.openConnection();
                conn.connect();
                is = conn.getInputStream();
                final Drawable drawable = Drawable.createFromStream(is, "src");
                mLoader.cache(mPath, drawable);
                mHandler.post(new Runnable() {

                    @Override
                    public void run() {
                        LogUtils.d(TAG, "load image success:" + mPath);
                        mCallback.onLoaded(drawable);
                    }
                });
            } catch (final Exception e) {
                LogUtils.e(TAG, e.getMessage() + "", e);
                mHandler.post(new Runnable() {

                    @Override
                    public void run() {
                        LogUtils.d(TAG, "load image failed:" + mPath);
                        mCallback.onError(e);
                    }
                });
            }
        }
    }

    /**
     * 回调接口,在主线程中运行
     * 
     */
    public static interface ImageCallback {
        /**
         * 加载成功
         * 
         * @param imageDrawable 下载下来的图片
         */
        public void onLoaded(Drawable drawable);

        /**
         * 加载失败
         * 
         * @param e 异常
         */
        public void onError(Exception e);
    }
}

转载于:https://my.oschina.net/javalover/blog/172465