Android图片加载

转载请注明出处：[作者CJstar]http://blog.csdn.net/cj_star/article/details/48526867

为什么要使用内存缓存
内存缓存：
内存缓存是指将已经赋值的对象保存在内存中，当再次使用的时候直接去内存读取，不再做重复的创建操作。

内存缓存的优势：
对象的重复使用，不再去创建对象，减少内存消耗，便于内存的集中管理。同时在需要读取数据库或者外存的时候，使用内存缓存将大大减少时间，提供程序的整体性能。

内存缓存的原理
JVM垃圾回收机制

JVM采用的是引用计数的机制，处理数据回收的问题。引用计数：即类被加载到内存以后，会在方法区，堆栈，以及程序计数器的地方分配相应的空间，同时对应产生一个引用计数器，专门计数对象被使用的情况。如果新的地方引用了对象，计数器就+1，引用销毁的时候计数器-1，当计数器为0的时候，对象被标记为可被回收。由于该机制不能处理互相引用的情况，加入了根搜索算法，解决互相引用时计数器始终>=1的情况。
引用的类型
强引用：

只要引用存在，垃圾回收器就不会回收。
如：
A a = new A();
B b = new B();
a.b = b;

这时候b属于a的强引用，只有a被回收后b才能被回收。

软引用：

软引用是非必须的引用，当内存不足时可被回收的 。
如：
Java
A a = new A();
SoftRefernece<A> softA = new SoftRefernece<A>(a);
softA.get();//取A的值

如果一个对象只具有软引用，则内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。


弱引用：

第二次垃圾回收时回收

Java
A a = new A();
WeakReference<A> weakA = new WeakReference<A>(a);
weakA.get();//获取A对象
weakA.isEnQueued();//返回垃圾回收器是否将其标记为可回收。

软引用第一次垃圾回收器扫描到的时候不会马上回收，会把它标记为可回收资源，第二次JVM回收内存的时候如果a还未被引用过，内存将被回收，这时softA.get()返回值是null。这样的好处是a对象可以短暂被保存，但是每次用get方法取值时都需要判断对象是否为空！

虚引用：

每次JVM回收垃圾的时候都会被回收。
Java
A a = new A();
PhantomReference<A> phantomA = new PhantomReference<A>(a);
phantomA.get();//永远返回null
phantomA.isEnQueued();//返回内存中已删除

虚引用是每次垃圾回收的时候都会被回收，通过虚引用的get方法永远获取到的数据为null，因此也被成为幽灵引用。

内存缓存的实现策略

Java
/**
* Created by CJstar on 15/9/2.
*/
public class LRUBitmapMemoryCache implements MemmoryCache<Bitmap> {

    private static final String TAG = "LRUBitmapMemoryCache";

    private MemoryCacheOptions options;
//强引用
    private LruCache<String, Bitmap> mMemoryCache;
//软引用
    private LinkedHashMap<String, SoftReference<Bitmap>> mSoftCache;

    /**
     * Create a instance by default config
     */
    public LRUBitmapMemoryCache() {
        options = new MemoryCacheOptions.Builder()
                .setmMaxCacheCount(DefaultConfig.MemoryCacheDefaultOptions.MAXCACHECOUNT)
                .setmMaxCacheSize(DefaultConfig.MemoryCacheDefaultOptions.MAXCACHESIZE)
                .setmUseCache(DefaultConfig.MemoryCacheDefaultOptions.USECACHE)
                .build();
        initializeCache();
    }

    /**
     * set a options as you set
     *
     * @param defaultOptions
     */
    @Override
    public void setOptions(MemoryCacheOptions defaultOptions) {
        this.options = defaultOptions;
    }

    private void initializeCache() {

        if (options == null) {
            throw new VinciException("LRUBitmapMemoryCache#options is null");
        }

        if (options.getmMaxCacheSize() == 0) {
            throw new VinciException("LRUBitmapMemoryCache#max cache size is o");
        }

        if (options.getmMaxCacheCount() == 0) {
            throw new VinciException("LRUBitmapMemoryCache#max cache count is o");
        }

        MLog.d(TAG, "maxSize:" + options.getmMaxCacheSize() + " maxCount:" + options.getmMaxCacheCount());
        mMemoryCache = new LruCache<String, Bitmap>(options.getmMaxCacheSize()) {
            @Override
            protected int sizeOf(String key, Bitmap bitmap) {
                // The cache size will be measured in kilobytes rather than
                // number of items.
                return bitmap.getRowBytes() * bitmap.getHeight() / 1024;
            }

            @Override
            protected void entryRemoved(boolean evicted, String key, Bitmap oldValue, Bitmap newValue) {
                // TODO Auto-generated method stub
                super.entryRemoved(evicted, key, oldValue, newValue);
                if (oldValue != null) {
                    // the allocation is full, move bitmap to soft reference
                    mSoftCache.put(key, new SoftReference<Bitmap>(oldValue));
                    testLog("entryRemoved to mSoftCache:" + key);
                }

            }
        };

        mSoftCache = new LinkedHashMap<String, SoftReference<Bitmap>>(
                options.getmMaxCacheCount(), 0.75f, true) {
            private static final long serialVersionUID = 6040103833179403725L;

            @Override
            protected boolean removeEldestEntry(
                    Entry<String, SoftReference<Bitmap>> eldest) {
                if (size() > options.getmMaxCacheCount()) {
                    testLog("removeEldestEntry true");
                    return true;
                }

                testLog("removeEldestEntry full");
                return false;
            }
        };
    }

    @Override
    public Bitmap get(String key) {
        testLog("get:" + key);

        if (TextUtils.isEmpty(key)) {
            return null;
        }

        Bitmap bitmap;

        // get bitmap from mMemoryCache
        synchronized (mMemoryCache) {
            bitmap = mMemoryCache.get(key);

            if (bitmap != null && !bitmap.isRecycled()) {
                // LRU : refresh this bitmap position
                mMemoryCache.remove(key);
                mMemoryCache.put(key, bitmap);
                testLog("get mMemoryCache");

                return bitmap;
            }

        }

        // get bitmap from mSoftCache
        synchronized (mSoftCache) {
            SoftReference<Bitmap> bitmapReference = mSoftCache.get(key);
            if (bitmapReference != null) {
                bitmap = bitmapReference.get();

                if (bitmap != null && !bitmap.isRecycled()) {
                    // move bitmap to mSoftCache
                    mMemoryCache.put(key, bitmap);
                    mSoftCache.remove(key);
                    testLog("get mSoftCache");

                    return bitmap;

                } else {
                    // is recycled
                    mSoftCache.remove(key);
                }
            }
        }

        return null;
    }

    @Override
    public boolean isExist(String key) {
        if (TextUtils.isEmpty(key)) {
            return false;
        }

        Bitmap bitmap;

        // get bitmap from mMemoryCache
        synchronized (mMemoryCache) {
            bitmap = mMemoryCache.get(key);
            if (bitmap != null && !bitmap.isRecycled()) {
                return true;
            }
        }

        // get bitmap from mSoftCache
        synchronized (mSoftCache) {
            SoftReference<Bitmap> bitmapReference = mSoftCache.get(key);
            if (bitmapReference != null) {
                bitmap = bitmapReference.get();
                if (bitmap != null && !bitmap.isRecycled()) {
                    return true;
                }
            }
        }


        return false;
    }

    @Override
    public Bitmap remove(String key) {
        // remove bitmap from mMemoryCache
        Bitmap bitmap;
        synchronized (mMemoryCache) {
            bitmap = mMemoryCache.remove(key);
        }

        // remove bitmap from mSoftCache
        synchronized (mSoftCache) {
            if (bitmap != null && !bitmap.isRecycled()) {
                mSoftCache.remove(key);

            } else {
                SoftReference<Bitmap> bitmapReference = mSoftCache.remove(key);
                if (bitmapReference != null) {
                    bitmap = bitmapReference.get();
                }
            }
        }

        return bitmap;
    }

    @Override
    public void put(String key, Bitmap bitmap) {
        if (bitmap == null || bitmap.isRecycled()) {
            return;
        }

        testLog("put:" + key);
        // thread synchronize
        synchronized (mMemoryCache) {
            mMemoryCache.put(key, bitmap);
        }
    }

    @Override
    public void clear() {
        synchronized (mMemoryCache) {
            mMemoryCache.evictAll();
        }

        synchronized (mSoftCache) {
            mSoftCache.clear();
        }
    }


    private final boolean ISDEBUG = false;

    private void testLog(String str) {
        if (ISDEBUG) {
            MLog.e(TAG, str);
        }
    }
}


这个缓存是基于LRU算法的缓存机制，LRU即最久未使用算法，当内存不足时将最久未使用的对象放入软引用区，当内存不足时可以及时释放。

[项目的GitHub地址](https://github.com/CJstar/Vinci)