登录 立即注册
安币:

大规模图片缓存方案 [复制链接]

2018-7-24 17:56
Mob开发者平台 阅读:413 评论:2 赞:1
Tag:  

前言

之前因为很喜欢 ReLIFE 那部动画,所以从百度云上下载了 500MB 左右的漫画全集(此时应该喊 “完结撒花” 吗(笑)),打算在手机上看。可是直接用图库之类的软件看起来会很累,所以花了点时间做了个应用(程序员的唯一好处): ViewPager 嵌套 ListView,横向为每一话的漫画,纵向是该话的内容。

初步跑起来是可以看,但纵向滑动的时候很卡。经查发现是解码 jpg 为 bitmap 这个地方很慢,所以看来只能异步加载。试了一下,虽然流畅一点,可是列表在 “飘” 的时候,会看到很多默认图片,之后才显示出来漫画的图片。如果一次性全部解码到内存呢?我曾这么想过,但立刻被证实是愚蠢的想法,漫画的一话内容,可能会有几十张图片,张张大图,全部解码,内存必然会爆掉。幸亏做 rec 的时候,发现 bitmap 可以从 biyebuffer 中复制像素数据,也可以将像素数据复制到 bytebuffer 中, 所以试过 “愚蠢方案” 之后,我打算利用这个特性来做一个“基于虚拟内存的图片缓存方案”。

ByteBuffer

顾名思义,这是一个 “缓存” 之类的东西,但是我更愿意将它理解为 java 语言的“高级指针”。

平时我们也会经常使用缓存,比如一个 byte 数组。而 ByteBuffer 除了包含一块元素为 byte 类型的存储区域以外,还包含了一个指向这块区域某处的 position、这块区域结束位置的 limit,并且一个 bytebuffer 还能“生出(duplicate)”另一个与其共享存储区域,但 position 和 limit 完全独立的 bytebuffer 出来。

除此之外,bytebuffer 具备一些好玩的功能,比如虽然我们以一个 byte 数组来创建一个 bytebuffer,但却可以将其转为一个 intbuffer、charbuffer 之类,元素类型非 byte 的缓存对象,之前我对 musical.ly 的安卓半年崩溃日志做去重的时候就大量使用了 bytebuffer 和 charbuffer 互转的功能。

不过最厉害的应该是 java 在 FileChannel 类中提供了将磁盘文件的一个区域 map 到内存中作为一个 bytebuffer 的功能,而本文要介绍的“方案”就是基于这个功能来做。

方案一:单文件缓存方案

流程图

我将这个工具叫做 “ImageBuffer” 。它主要包含 open、put、get 和 close 几个主要方法,下面这几个方法的实现流程图:

图片描述

imagebuffer 只是提供了 reset 的功能,但没有提供 remove,而且 reset 也只是将索引队列清空、将 raf 的位置归零而已。之所以不做 remove,是因为从流程图可以看出,像素数据都缓存在文件里面,remove 掉一个缓存元素,除了从索引中这个对象外,实际上对缓存文件没有任何影响,所以名不副实。

另一方面,imagebuffer 可以说是没有容量限制的,而且由于少了解码的操作,还原图片的速度甚至比所谓“多级缓存”的文件缓存要还要快——我就是为了比它快才做 imagebuffer。

从更长远来说,imangebuffer 可以不仅缓存在一个文件里面,而是每一个图片都缓存在一个单独的文件,并在其关闭前一直保留隐射,这样子只是在 put 时稍慢(因为要打开文件),但 get 不受影响,而且删除功能还可以实际实现。进一步,如果缓存文件可以不删除——或者采用 LRU 的方式删除长久不使用的,则只要保存索引,可以作为替代现在 mobtools 中多级缓存中的文件缓存方案。

当然,imagebuffer 有明显的缺点,因为缓存在文件中的是 rgb 的像素数据,所以缓存时文件会比 jpg 的大很多,很浪费磁盘空间。

源码

import android.graphics.Bitmap;
import android.graphics.Bitmap.Config;
 
import java.io.File;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel.MapMode;
import java.util.ArrayList;
 
public class ImageBuffer {
   private File file;
   private RandomAccessFile raf;
   private int position;
   private ArrayList<Image> buffers;
   private byte[] buffer;
    
   public void open() throws Throwable {
      open(null);
   }
    
   public synchronized void open(File file) throws Throwable {
      if (this.file == null) {
         if (file == null) {
            file = File.createTempFile("ib_", "");
         }
         if (!file.getParentFile().exists()) {
            file.getParentFile().mkdirs();
         }
         this.file = file;
         raf = new RandomAccessFile(file, "rw");
         position = 0;
         buffers = new ArrayList<Image>();
      }
   }
    
   public synchronized void reset() throws Throwable {
      raf.seek(0);
      position = 0;
      buffers = new ArrayList<Image>();
   }
    
   public synchronized void close() throws Throwable {
      if (file != null) {
         raf.close();
         file.delete();
         file = null;
         raf = null;
         buffer = null;
         position = 0;
         buffers = null;
      }
   }
    
   public synchronized boolean put(Bitmap bm) throws Throwable {
      if (file != null) {
         int bc = bm.getByteCount();
         if (buffer == null || buffer.length < bc) {
            buffer = new byte[bc];
         }
         ByteBuffer bb = ByteBuffer.wrap(buffer);
         bm.copyPixelsToBuffer(bb);
         return put(buffer, 0, bc, bm.getWidth(), bm.getHeight(), bm.getConfig());
      }
      return false;
   }
    
   public synchronized boolean put(byte[] pixels, int offset, int len, int width, int height, Config config)
         throws Throwable {
      if (file != null) {
         raf.write(pixels, offset, len);
         ByteBuffer bb = raf.getChannel().map(MapMode.READ_ONLY, position, len);
         position += len;
          
         Image image = new Image();
         image.config = config;
         image.width = width;
         image.height = height;
         image.buffer = bb;
         return buffers.add(image);
      }
      return false;
   }
    
   public synchronized Bitmap get(int index) throws Throwable {
      if (buffers == null || index < 0 || buffers.size() < index) {
         return null;
      }
       
      Image image = buffers.get(index);
      image.buffer.position(0);
      Bitmap bm = Bitmap.createBitmap(image.width, image.height, image.config);
      bm.copyPixelsFromBuffer(image.buffer);
      return bm;
   }
    
   public synchronized int size() {
      return buffers == null ? 0 : buffers.size();
   }
    
   private class Image {
      private int width;
      private int height;
      private ByteBuffer buffer;
      private Config config;
   }
    
}

方案二:多文件缓存方案

前段时间做了方案一,但是对于它不能删除失效缓存的特性很是不舒服,所以做了下面基于文件夹(多文件)的方案:

源码

import android.graphics.Bitmap;
import android.graphics.Bitmap.Config;
 
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel.MapMode;
import java.util.HashMap;
 
public class ImageBuffer {
   private File folder;
   private byte[] buffer;
   private HashMap<String, Image> buffers;
    
   public ImageBuffer(String folder) {
      this(new File(folder));
   }
    
   public ImageBuffer(File folder) {
      this.folder = folder;
      buffers = new HashMap<String, Image>();
   }
    
   public void put(String key, Bitmap bm) throws Throwable {
      int bc = bm.getByteCount();
      ByteBuffer bb;
      synchronized (this) {
         if (buffer == null || buffer.length < bc) {
            buffer = new byte[bc];
         }
         bb = ByteBuffer.wrap(buffer);
      }
      bm.copyPixelsToBuffer(bb);
      put(key, buffer, 0, bc, bm.getWidth(), bm.getHeight(), bm.getConfig());
   }
    
   public void put(String key, byte[] pixels, int offset, int len, int width, int height,
         Config config) throws Throwable {
      saveImage(key, pixels, offset, len, width, height, config);
      openImage(key);
   }
    
   private void openImage(String name) throws Throwable {
      File file = new File(folder, name);
      synchronized (this) {
         if (!file.exists()) {
            return;
         }
      }
       
      int width = 0;
      int height = 0;
      Config config = null;
      RandomAccessFile raf = new RandomAccessFile(file, "r");
      ByteBuffer bb = raf.getChannel().map(MapMode.READ_ONLY, 0, file.length());
      int id = bb.getInt();
      while (id != -1) {
         switch (id) {
            case 0: {
               width = bb.getInt();
            } break;
            case 1: {
               height = bb.getInt();
            } break;
            case 2: {
               switch(bb.getInt()) {
                  case 1: config = Config.ALPHA_8; break;
                  case 3: config = Config.RGB_565; break;
                  case 4: config = Config.ARGB_4444; break;
                  case 5: config = Config.ARGB_8888; break;
               }
            } break;
         }
         id = bb.getInt();
      }
      raf.seek(0);
       
      Image image = new Image();
      image.file = file;
      image.raf = raf;
      image.buffer = raf.getChannel().map(MapMode.READ_ONLY, bb.position(), bb.remaining());
      image.width = width;
      image.height = height;
      image.config = config;
       
      synchronized (this) {
         buffers.put(name, image);
      }
   }
    
   private void saveImage(String key, byte[] pixels, int offset, int len, int width, int height, Config config)
         throws Throwable {
      Image image;
      synchronized (this) {
         image = buffers.remove(key);
      }
      if (image != null) {
         closeImage(image, true);
      }
       
      File file = new File(folder, key);
      synchronized (this) {
         if (!folder.exists()) {
            folder.mkdirs();
         }
      }
      FileOutputStream fos = new FileOutputStream(file);
      DataOutputStream dos = new DataOutputStream(fos);
      dos.writeInt(0);
      dos.writeInt(width);
      dos.writeInt(1);
      dos.writeInt(height);
      dos.writeInt(2);
      switch(config) {
         case ALPHA_8: dos.writeInt(1); break;
         case RGB_565: dos.writeInt(3); break;
         case ARGB_4444: dos.writeInt(4); break;
         case ARGB_8888: dos.writeInt(5); break;
      }
      dos.writeInt(-1);
      dos.write(pixels, offset, len);
      dos.flush();
      dos.close();
   }
    
   private void closeImage(Image image, boolean delete) throws Throwable {
      if (image != null) {
         image.raf.close();
         if (delete) {
            image.file.delete();
         }
      }
   }
    
   public Bitmap get(String key) throws Throwable {
      Image image;
      synchronized(this) {
         image = buffers.get(key);
      }
      if (image == null) {
         openImage(key);
         synchronized(this) {
            image = buffers.get(key);
         }
         if (image == null) {
            return null;
         }
      }
       
      image.buffer.position(0);
      Bitmap bm = Bitmap.createBitmap(image.width, image.height, image.config);
      bm.copyPixelsFromBuffer(image.buffer);
      return bm;
   }
    
   public void remove(String key) throws Throwable {
      remove(key, false);
   }
    
   public void remove(String key, boolean delete) throws Throwable {
      Image image;
      synchronized (this) {
         image = buffers.remove(key);
      }
      closeImage(image, delete);
   }
    
   public void clear() throws Throwable {
      clear(false);
   }
    
   public void clear(boolean delete) throws Throwable {
      synchronized(this) {
         for (Image image : buffers.values()) {
            closeImage(image, delete);
         }
         buffers.clear();
      }
   }
    
   public int size() {
      synchronized(this) {
         return buffers.size();
      }
   }
    
   private class Image {
      private File file;
      private RandomAccessFile raf;
      private ByteBuffer buffer;      // id = -1
      private int width;              // id = 0
      private int height;             // id = 1
      private Config config;          // id = 2
   }
    
}

补充说明

1、分文件存储图片,每一个图片一个文件,故删除和清理有了实际意义,而打开、关闭和重置都没有意义了;

2、图片描述跟随缓存,因此每一个缓存文件都分头部和数据体;

3、删除和清理可以选择逻辑删除和物理删除,逻辑删除只会在内存中删除索引 Image 对象,物理删除就是删除文件了;

4、由于图片独立存储,故同步锁的粒度可以降低,某种程度上提高效率(吧……)。

文/勋勋

分享到:
我来说两句
facelist
您需要登录后才可以评论 登录 | 立即注册
所有评论(2)
vs一页书 2018-7-25 10:14
很给力,安卓巴士有你更精彩!
回复
Mob开发者平台 2018-7-25 10:53
vs一页书: 很给力,安卓巴士有你更精彩!
  
回复

站长推荐

通过邮件订阅最新安卓weekly信息
上一条 /4 下一条

下载安卓巴士客户端

全国最大的安卓开发者社区

广告投放| 下载客户端|申请友链|手机版|站点统计|安卓巴士 ( 粤ICP备15117877号 )

返回顶部