LruCache缓存使用

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;
  }