Bitmap使用中的两级缓存，及内存重用

谁践踏了优雅 2023-07-01 11:59 11阅读 0赞

案例是测试Bitmap使用过程中，如何使用二级缓存，及重用bitmap的内存

这里的二级缓存，一是内存缓存，而是磁盘缓存。

代码中已加注释，所以可以直接看代码：

一，首先是主Activity，其中会设置recyclerView的布局类型，适配器，设置磁盘缓存的路径。

public class MainActivity extends AppCompatActivity {
        private final String TAG = MainActivity.class.getName();
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            RecyclerView rv = findViewById(R.id.rv);
            LinearLayoutManager llm = new LinearLayoutManager(this);
            rv.setLayoutManager(llm);
    
            BitmapAdapter bitmapAdapter = new BitmapAdapter(this);
            rv.setAdapter(bitmapAdapter);
            ImageCache.getInstance().init(this, this.getExternalCacheDir() +"/bitmap");
            Log.d(TAG,"this.getExternalCacheDir()="+this.getExternalCacheDir());
        }
    
        @Override
        protected void onResume() {
            super.onResume();
            ImageCache.getInstance().setExit(false);
        }
    
        @Override
        protected void onStart() {
            super.onStart();
        }
    
        @Override
        protected void onStop() {
            super.onStop();
            ImageCache.getInstance().interruptThread();
        }
    
        @Override
        protected void onDestroy() {
            super.onDestroy();
            ImageCache.getInstance().interruptThread();
        }
    }

二，RecyclerView适配器，为测试方便，显示条目写了固定值，在加载每项数据时，先从内存缓存获取，然后是磁盘缓存，

这个过程中考虑了bitmap的内存重用。

public class BitmapAdapter extends RecyclerView.Adapter<BitmapAdapter.BitmapViewHolder> {
        private Context mContext;
        private final String TAG = BitmapAdapter.class.getName();
    
        public BitmapAdapter(Context context) {
            mContext = context;
        }
    
        @NonNull
        @Override
        public BitmapViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
            View item = LayoutInflater.from(mContext).inflate(
                    R.layout.rv_item, null, false);
            BitmapViewHolder bitmapViewHolder = new BitmapViewHolder(item);
            return bitmapViewHolder;
        }
    
        @Override
        public void onBindViewHolder(@NonNull BitmapViewHolder holder, int position) {
            Log.d("BitmapAdapter","position="+position);
            //应用缓存，及复用Bitmap，首先从内存缓存读取
            Bitmap bitmap = ImageCache.getInstance().getBitmapFromMemory(String.valueOf(position));
            if (bitmap != null) {
                Log.d(TAG, "memory cache in use..." + bitmap);
            }
    
            if (bitmap == null) {
                //先检查是否有可复用内存,为方便测试，宽高比实际加载的bitmap稍小一点
                Bitmap reusable = ImageCache.getInstance().getReusable(298, 298, 1);
                if (reusable != null) {
                    Log.d(TAG, "reusable bitmap in use..." + reusable);
                }
                //如果reusable是null，在BitmapFactory.cpp的处理中会忽略掉重用
                bitmap = ImageCache.getInstance().getBitmapFromDisk(String.valueOf(position), reusable);
                if (bitmap != null) {
                    Log.d(TAG, "disk bitmap in use..." + bitmap);
                }
                //初次使用，肯定要先加载，从本地或者网络，然后放入缓存，磁盘
                if (bitmap == null) {
                    bitmap = ImageResize.resizeBitmap(mContext, R.drawable.jpgfile,
                            300, 300, false ,reusable);
                    ImageCache.getInstance().putBitmap2Memory(String.valueOf(position) , bitmap);
                    ImageCache.getInstance().putBitmap2Disk(String.valueOf(position), bitmap);
                }
            }
            if (bitmap != null) {
                holder.iv.setImageBitmap(bitmap);
            }
        }
    
        @Override
        public int getItemCount() {
            //仅做测试，总共500条数据，实际根据列表size来定
            return 500;
        }
    
        class BitmapViewHolder extends RecyclerView.ViewHolder {
            private ImageView iv;
            public BitmapViewHolder(@NonNull View itemView) {
                super(itemView);
                iv = itemView.findViewById(R.id.iv);
            }
        }
    }

三，内存缓存，磁盘缓存，对象复用的代码实现

其中LRUCache调用entryRemoved方法,移除图片时,需要注意下:

当bitmap.isMutable()为true可以复用,就放入复用池,这种情况就不能调用recycle,否则在后面去判断Bitmap使用复用池时,

会报错(can't access free/invalide bitmap).

如果不能复用,直接recycle掉,

public class ImageCache {
        private final String TAG= ImageCache.class.getName();
        private static ImageCache imageCache = new ImageCache();
        private Context mContext;
        //bitmap对象复用池
        private Set<WeakReference<Bitmap>> mReusablePool;
        private LruCache<String, Bitmap> mMemoryCache;
        //先要下载DiskLruCache的源码
        private DiskLruCache mDiskLruCache;
        private ReferenceQueue<Bitmap> mReferenceQueue;
        private boolean mExit;
        private Thread mRqThread;
    
        public static ImageCache getInstance() {
            return imageCache;
        }
    
        public void init(Context context, String diskCacheDir) {
            mContext = context;
            mReusablePool = Collections.synchronizedSet(new HashSet<WeakReference<Bitmap>>());
            //计算当前进程的内存大小
            ActivityManager am = (ActivityManager)mContext.getSystemService(Context.ACTIVITY_SERVICE);
            //单位是megabytes
            int memory = am.getMemoryClass();
            Log.d(TAG,"memory="+memory);
            //参数size单位是byte,
            mMemoryCache = new LruCache<String, Bitmap>(memory * 1024 * 1024 / 10) {
                @Override
                protected void entryRemoved(boolean evicted, String key, Bitmap oldValue, Bitmap newValue) {
                    //当一个bitmap被lrucache移除时，考虑复用这个bitmap对象
                    Log.d(TAG,"key="+key+",evicted="+evicted+",oldValue="+oldValue);
                    if (oldValue.isMutable()) {
                        //把引用添加到复用池，同时注册到一个引用队列上，在这个引用被引用的对象被GC时，
                        // 这个引用会被追加到这个队列中
                        mReusablePool.add(new WeakReference<Bitmap>(oldValue, getReferenceQueue()));
                    } else {
                        oldValue.recycle();
                    }
                }
    
                @Override
                protected int sizeOf(String key, Bitmap value) {
                    //一张图片的大小
                    Log.d(TAG,"value.getAllocationByteCount()="+value.getAllocationByteCount());
                    return value.getAllocationByteCount();
                }
            };
    
            try {
                mDiskLruCache = DiskLruCache.open(new File(diskCacheDir),
                        BuildConfig.VERSION_CODE,
                        1, 10 * 1024 * 1024);
            } catch (IOException e) {
                e.printStackTrace();
            }
    
        }
    
        //使用这个队列的目标，就是跟踪对象的回收，来检测内存泄漏
        private ReferenceQueue<Bitmap> getReferenceQueue() {
            if (mReferenceQueue == null) {
                mReferenceQueue = new ReferenceQueue<>();
                mRqThread = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        //确保线程能正常退出。
                        while (!isExit() &&
                                !Thread.currentThread().isInterrupted()) {
                            try {
                                Reference<? extends Bitmap> rmove = mReferenceQueue.remove();
                                //如果一个引用-引用的对象被回收了，那么这个引用本身也应该释放掉。
                                Bitmap bitmap = rmove.get();
                                Log.d(TAG,"getReferenceQueue,bitmap="+bitmap);
                                if (bitmap != null && !bitmap.isRecycled()) {
                                    bitmap.recycle();
                                }
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                                return;
                            }
                        }
                    }
                });
                mRqThread.start();
            }
            return mReferenceQueue;
        }
    
        public boolean isExit() {
            return mExit;
        }
    
        public void setExit(boolean mExit) {
            this.mExit = mExit;
        }
    
        public void interruptThread() {
            setExit(true);
            mRqThread.interrupt();
            Log.d(TAG,"isInterrupted="+mRqThread.isInterrupted());
        }
    
        //把bitmap放入缓存
        public void putBitmap2Memory(String key, Bitmap bitmap) {
            mMemoryCache.put(key, bitmap);
        }
    
        //从缓存读取bitmap
        public Bitmap getBitmapFromMemory(String key) {
            return mMemoryCache.get(key);
        }
    
        //清空缓存
        public void clearMemory() {
            mMemoryCache.evictAll();
        }
    
        //把bitmap放入磁盘
        public void putBitmap2Disk(String key, Bitmap bitmap) {
            DiskLruCache.Snapshot snapshot = null;
            OutputStream os = null;
            //先判断磁盘中有没有，如果没有就写入
            try {
                snapshot = mDiskLruCache.get(key);
                if (snapshot == null) {
                    DiskLruCache.Editor editor = mDiskLruCache.edit(key);
                    //写入文件前，做压缩
                    os = editor.newOutputStream(0);
                    bitmap.compress(Bitmap.CompressFormat.JPEG, 60, os);
                    editor.commit();
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (snapshot != null) {
                    snapshot.close();
                }
                if (os != null) {
                    try {
                        os.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    
        //从磁盘读取bitmap
        public Bitmap getBitmapFromDisk(String key, Bitmap reusable) {
            DiskLruCache.Snapshot snapshot = null;
            Bitmap bitmap = null;
            try {
                snapshot = mDiskLruCache.get(key);
                if (snapshot == null) {
                    return null;
                }
                InputStream is = snapshot.getInputStream(0);
                BitmapFactory.Options options = new BitmapFactory.Options();
                //重用bitmap的内存
                options.inMutable = true;
                options.inBitmap = reusable;
                bitmap = BitmapFactory.decodeStream(is, null, options);
                if (bitmap != null) {
                    mMemoryCache.put(key, bitmap);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            return bitmap;
        }
    
        //判断bitmap的内存是否可以重用，根据inBitmap的注释，将要解码的bitmap的内存要小于等于
        // 被重用bitmap的内存。
        public Bitmap getReusable(int width, int height, int inSampleSize) {
            Bitmap reusable = null;
            Iterator<WeakReference<Bitmap>> iterator = mReusablePool.iterator();
            while (iterator.hasNext()) {
                Bitmap bitmap = iterator.next().get();
                if (bitmap != null) {
                    if (checkReusableBitmap(bitmap, width, height, inSampleSize)) {
                        reusable = bitmap;
                        iterator.remove();
                        break;
                    }
                } else {
                    iterator.remove();
                }
            }
            return reusable;
        }
    
        private boolean checkReusableBitmap (Bitmap bitmap, int width, int height, int inSampleSize) {
            if (inSampleSize > 1) {
                width /= inSampleSize;
                height /= inSampleSize;
            }
    
            int byteCount = width * height * getBytesPerPixel(bitmap.getConfig());
            return byteCount <= bitmap.getAllocationByteCount();
        }
    
        //单个像素占的字节数
        private int getBytesPerPixel(Bitmap.Config config) {
            if (config == Bitmap.Config.ARGB_8888) {
                return 4;
            }
            return 2;
        }
    }

在android8.0之前,Bitmap的内存是在java层分配的,JVM在GC时会去调用bitmap.recycle,所以8.0通常不用主动去调用recycle,但是建议还是主动去recycle,以便告诉jvm这块空间不需要了,可以及时回收.

在android8.0之后,可能因为在java层分配太占空间,所以Bitmap内存又在native分配,这时GC就管不了这块空间了,所以要主动recycle.

在复用池中，对bitmap对象的引用使用的是弱引用，在应用弱引用时，同时关联了引用队列，这样在 ，被弱引用引用的bitmap对象被回收时，可以通过引用队列的操作，回收到引用本身，因为引用本身也是bitmap类型的变量，也需要手动执行bitmap.recyle(),给一个适当的清理机制，避免大量的WeakReference对象带来内存泄漏。

另外,因为ReferenceQueue的remove操作是阻塞的,所以要放在一个单独的线程去完成.

四，在第一次加载图片时，根据需要的宽高简单做个缩放

public class ImageResize {
    
        public static Bitmap resizeBitmap(Context context,int id, int desiredWidth, int desireHeight,
                                          boolean alpha, Bitmap reusable) {
            Resources resources = context.getResources();
            BitmapFactory.Options options = new BitmapFactory.Options();
            //仅解析out参数
            options.inJustDecodeBounds = true;
            BitmapFactory.decodeResource(resources,id, options);
            int width = options.outWidth;
            int height = options.outHeight;
            //计算缩放比例
            options.inSampleSize = calculateInSampleSize(width,height,desiredWidth,desireHeight);
            //如果不需要透明，重新设置颜色配置
            if (!alpha) {
                options.inPreferredConfig = Bitmap.Config.RGB_565;
            }
            options.inJustDecodeBounds = false;
    
            //复用Bitmap
            options.inMutable = true;
            options.inBitmap = reusable;
    
            return BitmapFactory.decodeResource(resources, id, options);
        }
    
        public static int calculateInSampleSize(int originalW, int originalH, int desiredW, int desiredH) {
            int inSampleSize = 1;
            //inSampleSize是2的指数次幂
            if (originalW > desiredW && originalH > desiredH) {
                inSampleSize = 2;
                while (originalW / inSampleSize > desiredW && originalH / inSampleSize > desiredH) {
                    inSampleSize *=2;
                }
            }
            return inSampleSize;
        }
    }

五，布局文件不粘贴了，就是一个RecyclerView。