1.为什么要缓存？
在android项目中经常需要请求网络图片，这个时候如果每张网络图片显示都要去获取一次的话，是非常耗费性能的。从网络中成功获取一张图片需要发起请求、等待响应、接收数据、解析数据、在做显示。这一系列操作我们都需要放到子线程中去执行，确认程序不会出现ANR问题。
对于缓存来说，无法就是添加缓存、删除缓存、获取缓存这三种操作。先判断是否有缓存，没有就进行缓存操作，当缓存满了之后我们就可以把最久没使用的缓存给清除掉，已达到不超出缓存边界的问题。
2.二种缓存方式
为了应对这种性能问题，我们有可以选择对图片进行缓存，在android中主要有二种方式来缓存，一种是内存缓存、磁盘缓存。内存缓存是最快的因为它是直接从内存中读取数据，磁盘缓存稍慢因为它要做IO流操作，但是它可以持久化数据，各有各的好处，所以我们可以结合情况二种方式都用上。
3.LruCache
结合以上出现的问题android在3.1的时候推出了一个LRU(Least Recently Used)最近期最少使用算法,它的核心思想就是，优先清除那些最近最少使用的对象。LRU体现有二种一个是内存中的LruCache和一个针对磁盘的DisLruCache。它们的核心都是LRU思想。
4.使用
这里初始化了一个LruCache类，构造函数我们传入了一个Int类型的 cacheSize参数，这个参数代表缓存的最大边界是当前显示的1/8的容量。
sizeOf
这个方法是计算每个缓存对象大小的，内部通过这个方法叠加大小看是否超过了，我们初始化构造函数中的大小。
private LruCache<String, Bitmap> mCache;
private Bitmap bitmap;
private LruCache<String, Bitmap> mCache;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.layout_glide);
img = findViewById(R.id.iamge);
initLRUCache();
findViewById(R.id.but).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Bitmap bitmap = getCacheImage("bitmap");
if (bitmap == null) {
requestImage();
} else {
Log.i("jinwei", "获取缓存");
img.setImageBitmap(bitmap);
}
}
});
private void initLRUCache() {
long maxMemory = Runtime.getRuntime().maxMemory();
int cacheSize = (int) (maxMemory / 8);
mCache = new LruCache<String, Bitmap>(cacheSize) {
@Override
protected int sizeOf(String key, Bitmap value) {
return value.getByteCount();
}
};
}
android.os.Handler handler = new android.os.Handler() {
@Override
public void dispatchMessage(Message msg) {
super.dispatchMessage(msg);
img.setImageBitmap(bitmap);
}
};
private void httpUrlConnectionImage() throws MalformedURLException {
Log.i("jinwei", "request Image");
URL url = new URL("https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1535715922665&di=b706c8b7a4f907a07b1f5062073a4e2a&imgtype=0&src=http%3A%2F%2Fwww.baimg.com%2Fuploadfile%2F2015%2F0413%2FBTW_2015041347455.jpg");
try {
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setReadTimeout(5000);
connection.setConnectTimeout(5000);
InputStream inputStream = connection.getInputStream();
bitmap = BitmapFactory.decodeStream(inputStream);
addCache("bitmap", bitmap);
handler.sendEmptyMessage(2);
} catch (IOException e) {
e.printStackTrace();
}
}
private void initLRUCache() {
long maxMemory = Runtime.getRuntime().maxMemory();
int cacheSize = (int) (maxMemory / 8);
mCache = new LruCache<String, Bitmap>(cacheSize) {
@Override
protected int sizeOf(String key, Bitmap value) {
return value.getByteCount();
}
};
}
/**
* 缓存取bitmap
*
* @param key key
* @return 缓存bm
*/
private Bitmap getCacheImage(String key) {
Bitmap mb = mCache.get(key);
return mb;
}
/**
* 移除缓存
*
* @param key
*/
private void removeCache(String key) {
mCache.remove(key);
}
/**
* 添加一个缓存
*
* @param key
* @param bitmap
*/
private void addCache(String key, Bitmap bitmap) {
if (getCacheImage(key) == null) {
mCache.put(key, bitmap);
}
}
private void requestImage() {
new Thread(new Runnable() {
@Override
public void run() {
try {
httpUrlConnectionImage();
} catch (MalformedURLException e) {
e.printStackTrace();
}
}
}).start();
}
原理分析
可以看到构造里面做的操作，初始化可一个LinkedHashMap，所有LRU的核心就是通过hasmap来存储缓存对象的，maxSize保存了传入预设的大小值。
private final LinkedHashMap<K, V> map;
/** Size of this cache in units. Not necessarily the number of elements. */
private int size;
private int maxSize;
private int putCount;
private int createCount;
private int evictionCount;
private int hitCount;
private int missCount;
public LruCache(int maxSize) {
if (maxSize <= 0) {
throw new IllegalArgumentException("maxSize <= 0");
}
this.maxSize = maxSize;
this.map = new LinkedHashMap<K, V>(0, 0.75f, true);
}
put方法
首先判断了key-value是否为null，为Null会抛出一个异常，所以LRU不支持key-value为null值。Lru的put方法是线程安全的，safeSizeOf就是会调用我们之前实现的sizeOf方法。
/**
* Caches {@code value} for {@code key}. The value is moved to the head of
* the queue.
*
* @return the previous value mapped by {@code key}.
*/
public final V put(K key, V value) {
if (key == null || value == null) {
throw new NullPointerException("key == null || value == null");
}
V previous;
synchronized (this) {
putCount++;
size += safeSizeOf(key, value);
previous = map.put(key, value);
if (previous != null) {
size -= safeSizeOf(key, previous);
}
}
if (previous != null) {
entryRemoved(false, key, previous, value);
}
trimToSize(maxSize);
return previous;
}
private int safeSizeOf(K key, V value) {
int result = sizeOf(key, value);
if (result < 0) {
throw new IllegalStateException("Negative size: " + key + "=" + value);
}
return result;
}
trimToSize
注释说明的检查最近最少使用的的对象进行清除，当然是要缓存超出边界了才会进行清除。size <= maxSize这个判断可以看出来。这个方法在put方法中调用，意思就是每次Put的时候都会检查当然的缓存容量，如果超出就会清除最近最少使用的对象。
/**
* Remove the eldest entries until the total of remaining entries is at or
* below the requested size.
*
* @param maxSize the maximum size of the cache before returning. May be -1
* to evict even 0-sized elements.
*/
public void trimToSize(int maxSize) {
while (true) {
K key;
V value;
synchronized (this) {
if (size < 0 || (map.isEmpty() && size != 0)) {
throw new IllegalStateException(getClass().getName()
+ ".sizeOf() is reporting inconsistent results!");
}
if (size <= maxSize) {
break;
}
Map.Entry<K, V> toEvict = map.eldest();
if (toEvict == null) {
break;
}
key = toEvict.getKey();
value = toEvict.getValue();
map.remove(key);
size -= safeSizeOf(key, value);
evictionCount++;
}
entryRemoved(true, key, value, null);
}
}
get
这个方法比较容易理解，mapValue = map.get(key);如果mapValue不为NUll就直接返回我们缓存的对象。
/**
* Returns the value for {@code key} if it exists in the cache or can be
* created by {@code #create}. If a value was returned, it is moved to the
* head of the queue. This returns null if a value is not cached and cannot
* be created.
*/
public final V get(K key) {
if (key == null) {
throw new NullPointerException("key == null");
}
V mapValue;
synchronized (this) {
mapValue = map.get(key);
if (mapValue != null) {
hitCount++;
return mapValue;
}
missCount++;
}
/*
* Attempt to create a value. This may take a long time, and the map
* may be different when create() returns. If a conflicting value was
* added to the map while create() was working, we leave that value in
* the map and release the created value.
*/
V createdValue = create(key);
if (createdValue == null) {
return null;
}
synchronized (this) {
createCount++;
mapValue = map.put(key, createdValue);
if (mapValue != null) {
// There was a conflict so undo that last put
map.put(key, mapValue);
} else {
size += safeSizeOf(key, createdValue);
}
}
if (mapValue != null) {
entryRemoved(false, key, createdValue, mapValue);
return mapValue;
} else {
trimToSize(maxSize);
return createdValue;
}
}
remove
remove直接会key 对应的对象清除掉，响应缓存容量也会减少。
/**
* Removes the entry for {@code key} if it exists.
*
* @return the previous value mapped by {@code key}.
*/
public final V remove(K key) {
if (key == null) {
throw new NullPointerException("key == null");
}
V previous;
synchronized (this) {
previous = map.remove(key);
if (previous != null) {
size -= safeSizeOf(key, previous);
}
}
if (previous != null) {
entryRemoved(false, key, previous, null);
}
return previous;
}
网友评论