前言
我们上一篇文章介绍了如何优化单张图片,下面我们看下如何优化一系列图片
Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.mipmap.ic_launcher);
for (int i = 0; i < 100; i++) {
bitmap = BitmapFactory.decodeResource(getResources(), R.mipmap.ic_launcher);
}
这段代码运行后占有内存大概是200m。下面我们让她具有异变功能。
BitmapFactory.Options options = new BitmapFactory.Options();
//复用内存块,设计成异变
options.inMutable = true;
Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.mipmap.ic_launcher,options);
for (int i = 0; i < 100; i++) {
options.inBitmap = bitmap;
bitmap = BitmapFactory.decodeResource(getResources(), R.mipmap.ic_launcher,options);
}
优化ListView
我们在布局中创建一个ListView,listView的item只有一张图片
第一次优化
我们创建一个ListView,当我们上下滑动item的时候发现native内存一直在增加,只要是新出现的图片,都会开辟新的内存地址。所以我们需要复用这些内存块。Android8.0后这些内存是放在native内存而不是Java堆内存
<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
>
<ListView
android:id="@+id/listView"
android:layout_width="match_parent"
android:layout_height="match_parent"
/>
</FrameLayout>
这是item的布局
<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
>
<ImageView
android:id="@+id/iv"
android:layout_width="80dp"
android:layout_height="80dp" />
</FrameLayout>
这是MainActivity的代码
ListView listView = findViewById(R.id.listView);
listView.setAdapter(new MyAdapter(this));
这是上一节课的ImageResize,我们让它具备异变功能。
package com.example.administrator.lsn7_demo;
import android.content.Context;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
public class ImageResize {
/**
* 缩放bitmap
* @param context
* @param id
* @param maxW
* @param maxH
* @param reusable增加异变功能
* @return
*/
public static Bitmap resizeBitmap(Context context,int id,int maxW,int maxH,boolean hasAlpha,Bitmap reusable){
Resources resources = context.getResources();
BitmapFactory.Options options = new BitmapFactory.Options();
// 只解码出 outxxx参数 比如 宽、高
options.inJustDecodeBounds = true;
BitmapFactory.decodeResource(resources,id,options);
//根据宽、高进行缩放
int w = options.outWidth;
int h = options.outHeight;
//设置缩放系数
options.inSampleSize = calcuteInSampleSize(w,h,maxW,maxH);
if (!hasAlpha){
options.inPreferredConfig = Bitmap.Config.RGB_565;
}
options.inJustDecodeBounds = false;
//设置成能复用
options.inMutable=true;
options.inBitmap=reusable;
return BitmapFactory.decodeResource(resources,id,options);
}
/**
* 计算缩放系数
* @param w
* @param h
* @param maxW
* @param maxH
* @return 缩放的系数
*/
private static int calcuteInSampleSize(int w,int h,int maxW,int maxH) {
int inSampleSize = 1;
if (w > maxW && h > maxH){
inSampleSize = 2;
//循环 使宽、高小于 最大的宽、高
while (w /inSampleSize > maxW && h / inSampleSize > maxH){
inSampleSize *= 2;
}
}
return inSampleSize;
}
}
我们在Adapter中设置图片
@Override
public View getView(int position, View convertView, ViewGroup parent) {
ViewHolder holder;
if (null == convertView) {
convertView = LayoutInflater.from(context).inflate(R.layout.item, parent, false);
holder = new ViewHolder(convertView);
convertView.setTag(holder);
} else {
holder = (ViewHolder) convertView.getTag();
}
Bitmap bitmap = ImageResize.resizeBitmap(context, R.mipmap.wyz_p,
80, 80, false);
holder.iv.setImageBitmap(bitmap);
return convertView;
}
第一次优化详解
我们现在向下滑动ListView,会发现它的Native层内存一直在增长,但是Java内存却没有增长,Android 8.0之前,bitmap的管理是放在Java堆的。现在的话这些内存是直接开在native层的。现在我们写内存管理框架就要处理native内存的问题。比如内存释放就要自己去处理。我们现在向上滑动ListView,内存还是在一直增加,并没有释放掉。因为不管你是上滑还是下滑,只要是新出现的图片,它都会开辟新的内存地址。也许你会说ListView的convertView会做优化,没错,但是我们使用图片并不全是在ListView中。比如其它的地方我们需要更新Bitmap,如果我们不做任何处理的话,这些更新会在内存中不断的开辟内存块。
怎么解决呢?我们要使用inBitmap属性,假如我们现在需要加载三张bitmap,第一张bitmap加载后我们在删除第一张Bitmap,加载第二张图片,这时候如果第二张图片不比第一张图片大,我们就可以复用第一张图片的内存块。第三张图片也可以这么加载。这就是内存复用
下面我们看下在代码中如何实现内存复用,这与Glide原理相同。我们可以把这些代码加入到ImageResize 中。
Bitmap bitmap=BitmapFactory.decodeResource(getResources());
for(int i=0;i<100;i++){
bitmap=BitmapFactory.decodeResource(getResources());
}
上面代码我们加载一百张图片,我们不使用内存池,即我们不复用内存块,我们可以发现native内存里显示占用了20MB
下面的代码我们使用复用池技术
BitmapFactory.Options options=new BitmapFactory.Options();
//如果要复用,需要设计成异变
options.inMutable=true;
//这样设置图片就具备了异变功能,可以使用inBitmap功能了
Bitmap bitmap=BitmapFactory.decodeResource(getResources(),R.mipmap.wyz_p,options);
for(int i=0;i<100;i++){
//以后使用的时候它会使用相同的一块内存
// bitmap所指向的内存块是可以复用的。我在加载新图片到这个内存的时候,
//有了这个选项它就可以用了
options.inBitmap=bitmap;
bitmap=BitmapFactory.decodeResource(getResources(),R.mipmap.wyz_p,options);
}
运行结果显示 现在加载100张图片需要的内存要少于20MB
第二次优化
申请图片第一次去内存缓存,第二次去磁盘缓存,第三次去网络获取。内存缓存和磁盘缓存可以使用LRU算法,在LRU算法中,所有的图片都是一个双向链表。我们使用哪一张图片,哪一张图片就放到链表的最前面,当有新的图片放入的时候,会把新的图片放到链表最前面,同时删除链表最后一张图片。
内存缓存我们是有这样的API可以使用,做磁盘缓存则需要自己下载库这是下载地址注意下载发布版本。
我们解压这个包,在src中找到这三个文件。放到我们的项目中,如下图
现在我们可以使用磁盘缓存了,我们自己做一个缓存机制;
我们的缓存包括内存缓存和磁盘缓存,我画一张图来解释下内存缓存
新建一个ImageCache,来管理缓存
package com.example.administrator.lsn7_demo;
import android.app.ActivityManager;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Build;
import android.util.LruCache;
import com.example.administrator.lsn7_demo.disk.DiskLruCache;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
/**
* 管理内存中的图片
*/
public class ImageCache {
private static ImageCache instance;
private Context context;
//内存缓存
private LruCache<String,Bitmap> memoryCache;
//磁盘缓存
private DiskLruCache diskLruCache;
//用于内存复用
BitmapFactory.Options options=new BitmapFactory.Options();
/**
* 定义一个复用沲
*/
public static Set<WeakReference<Bitmap>> reuseablePool;
//单例模式
public static ImageCache getInstance(){
if(null==instance){
synchronized (ImageCache.class){
if(null==instance){
instance=new ImageCache();
}
}
}
return instance;
}
//引用队列,在复用池中被释放的东西拉到这个队列里面,在引用队列俩面
//开辟一个死循环的线程,把这些图片一一删除
ReferenceQueue referenceQueue;
Thread clearReferenceQueue;
//线程开关
boolean shutDown;
private ReferenceQueue<Bitmap> getReferenceQueue(){
if(null==referenceQueue){
//当弱用引需要被回收的时候,会进到这个队列中
referenceQueue=new ReferenceQueue<Bitmap>();
//单开一个线程,去扫描引用队列中GC扫到的内容,交到native层去释放,我自己调用
//recycle()方法释放,这比GC要快
clearReferenceQueue=new Thread(new Runnable() {
@Override
public void run() {
while(!shutDown){
try {
//remove是阻塞式的,如果这个队列是空的,代码会一直停留在这一行
Reference<Bitmap> reference=referenceQueue.remove();
Bitmap bitmap=reference.get();
if(null!=bitmap && !bitmap.isRecycled()){
bitmap.recycle();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
clearReferenceQueue.start();
}
return referenceQueue;
}
//dir是用来存放图片文件的路径,磁盘缓存要存放的目录
public void init(Context context,String dir){
this.context=context.getApplicationContext();
//复用池,带锁的set集合
reuseablePool=Collections.synchronizedSet(new HashSet<WeakReference<Bitmap>>());
ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
//获取程序最大可用内存 单位是M
int memoryClass=am.getMemoryClass();
//这是Android提供好的API,参数表示能够缓存的内存最大值 单位是byte,一般情况下是能使用的内存的1/8
memoryCache=new LruCache<String,Bitmap>(memoryClass/8*1024*1024){
/**
* @return value占用的内存大小
*/
@Override
protected int sizeOf(String key, Bitmap value) {
//1,19之前 复用是必需同等大小,才能复用 inSampleSize=1
//2,19之后不同,比如第一次使用图片显示的时候,他是a大小,下一次复用内存的时候,只
//复用了a-10;value.getByteCount()只能得到a-10的内存而不是a.
//android 19后有一个API可以得到整块内存空间。我们应该返回的内存a,而不是a-10
if(Build.VERSION.SDK_INT > Build.VERSION_CODES.KITKAT){
//bitmaap在复用的时候19以后与以前不同
return value.getAllocationByteCount();
}
//取到的是图片大小而不是内存大小
return value.getByteCount();
}
/**
* 1,当lru满了,bitmap从lru中移除对象时(就是上文提到的链表),会回调
* 2,假设内存大小是10,并且已经放满,我们现在放入第十一张图片,原来的十张图片就会删除链表的最后一位
* 删除掉的这张图片就可以使用oldValue进行接收.
* 3,这些被删除的图片是在native层进行回收的。我们这里可以设计一个复用池,在内存中找不到的可以再
* native内存中寻找。相当于做了两级缓存。我们可以使用弱引用缓存native层里的东西
*/
@Override
protected void entryRemoved(boolean evicted, String key, Bitmap oldValue, Bitmap newValue) {
//
if(oldValue.isMutable()){//如果是设置成能复用的内存块,拉到java层来管理
//3.0以下 Bitmap native
//3.0以后---8.0之前 java
//8。0开始 native
//把这些图片放到一个复用沲中,复用池里面保存被删除的东东
reuseablePool.add(new WeakReference<Bitmap>(oldValue,referenceQueue));
}else{
//释放bitmap,图片就找不到啦
oldValue.recycle();
}
}
};
//做磁盘缓存
//参数:1,缓存的目录,2,app的版本,3,valueCount:表示一个key对应valueCount个文件,4,磁盘缓存的大小
try {
diskLruCache = DiskLruCache.open(new File(dir), BuildConfig.VERSION_CODE, 1, 10 * 1024 * 1024);
}catch(Exception e){
e.printStackTrace();
}
getReferenceQueue();
}
/**
* 往内存中存放图片
* @param key
* @param bitmap
*/
public void putBitmapToMemeory(String key,Bitmap bitmap){
memoryCache.put(key,bitmap);
}
//从内存中获取图片
public Bitmap getBitmapFromMemory(String key){
return memoryCache.get(key);
}
//清空内存
public void clearMemoryCache(){
memoryCache.evictAll();
}
/**
* 获取复用池中的内容
* @param w 图片的宽高,从复用池取东西,宽高只能比原图小
* @param h
* @param inSampleSize 必须大于等于1
* @return
*/
public Bitmap getReuseable(int w,int h,int inSampleSize){
//版本在3.0以前
if(Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB){
return null;
}
Bitmap reuseable=null;
//从复用池里面迭代
Iterator<WeakReference<Bitmap>> iterator = reuseablePool.iterator();
while(iterator.hasNext()){
//这里是弱引用,所以用get方法
Bitmap bitmap=iterator.next().get();
//我们每从复用池拿一个就把它从复用池删除掉,删掉的那个加入到LRU内存中
if(null!=bitmap){
//不为空表示可以复用
//检测是否能用
if(checkInBitmap(bitmap,w,h,inSampleSize)){
reuseable=bitmap;
iterator.remove();
break;
}else{
iterator.remove();
}
}
}
return reuseable;
}
/**
* 检测版本是否能用
* @param bitmap
* @param w
* @param h
* @param inSampleSize
* @return
*/
private boolean checkInBitmap(Bitmap bitmap, int w, int h, int inSampleSize) {
//版本在19以前
if(Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT){
return bitmap.getWidth()==w && bitmap.getHeight()==h && inSampleSize==1;
}
//19版本以后,进行缩放
if(inSampleSize>=1){
w/=inSampleSize;
h/=inSampleSize;
}
//宽X高X像素的字节个数
int byteCount=w*h*getPixelsCount(bitmap.getConfig());
//小于bitmap的存储空间就返回为真
//只有我现在申请的内存块比我图片像素占得更多,才可以复用,才能返回为真
return byteCount<=bitmap.getAllocationByteCount();
}
private int getPixelsCount(Bitmap.Config config) {
if(config==Bitmap.Config.ARGB_8888){
return 4;
}
return 2;
}
//磁盘缓存的处理
/**
* 加入磁盘缓存
*/
public void putBitMapToDisk(String key,Bitmap bitmap){
//snapshot进行编辑提交
DiskLruCache.Snapshot snapshot=null;
OutputStream os=null;
try {
snapshot=diskLruCache.get(key);
//如果缓存中已经有这个文件 不理他
if(null==snapshot){
//为空表示这个key不存在,也就是没有这个文件,那就生成这个文件
DiskLruCache.Editor editor=diskLruCache.edit(key);
if(null!=editor){
//0表示文件从头开始
os=editor.newOutputStream(0);
//压缩bitmap
bitmap.compress(Bitmap.CompressFormat.JPEG,50,os);
//压缩的图片存放到磁盘里
editor.commit();
}
}
} catch (IOException e) {
e.printStackTrace();
}finally {
if(null!=snapshot){
snapshot.close();
}
if(null!=os){
try {
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* 从磁盘缓存中取
*/
public Bitmap getBitmapFromDisk(String key,Bitmap reuseable){
DiskLruCache.Snapshot snapshot=null;
Bitmap bitmap=null;
try {
snapshot=diskLruCache.get(key);
if(null==snapshot){
//如果为空,说明缓存中没有图片,我们就从网络中加载
return null;
}
//获取文件输入流,读取bitmap
InputStream is=snapshot.getInputStream(0);
//解码个图片,写入
//可以异变的
options.inMutable=true;
options.inBitmap=reuseable;
bitmap=BitmapFactory.decodeStream(is,null,options);
if(null!=bitmap){
//之所以从磁盘中获取,是因为内存中读取不到,所以内存中也存一份
memoryCache.put(key,bitmap);
}
} catch (IOException e) {
e.printStackTrace();
} finally{
if(null!=snapshot){
snapshot.close();
}
}
return bitmap;
}
}
Adapter中使用
package com.example.administrator.lsn7_demo;
import android.content.Context;
import android.graphics.Bitmap;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.ImageView;
public class MyAdapter extends BaseAdapter {
private Context context;
public MyAdapter(Context context) {
this.context = context;
}
@Override
public int getCount() {
return 999;
}
@Override
public Object getItem(int position) {
return null;
}
@Override
public long getItemId(int position) {
return 0;
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
ViewHolder holder;
if (null == convertView) {
convertView = LayoutInflater.from(context).inflate(R.layout.item, parent, false);
holder = new ViewHolder(convertView);
convertView.setTag(holder);
} else {
holder = (ViewHolder) convertView.getTag();
}
//第一次优化
// Bitmap bitmap = ImageResize.resizeBitmap(context, R.mipmap.wyz_p,
// 80, 80, false);
//先从内存中读取,我们就用index作键
Bitmap bitmap=ImageCache.getInstance().getBitmapFromMemory(String.valueOf(position));
if(null==bitmap){
//如果内存没数据,就去复用池找
//大小一定小于等于原来的,我们原来是80X80,insampleSize大于等于一
//reuseable能复用的内存快,不是图片
//复用池里不是图片,是能复用的内存块
Bitmap reuseable=ImageCache.getInstance().getReuseable(60,60,1);
//从磁盘找
bitmap = ImageCache.getInstance().getBitmapFromDisk(String.valueOf(position),reuseable);
//如果磁盘中也没缓存,就从网络下载
if(null==bitmap){
//网络中下载图片
bitmap=ImageResize.resizeBitmap(context,R.mipmap.wyz_p,80,80,false,reuseable);
//加载到内存
ImageCache.getInstance().putBitmapToMemeory(String.valueOf(position),bitmap);
//加载到磁盘
ImageCache.getInstance().putBitMapToDisk(String.valueOf(position),bitmap);
Log.i("jett","从网络加载了数据");
}else{
Log.i("jett","从磁盘中加载了数据");
}
}else{
Log.i("jett","从内存中加载了数据");
}
holder.iv.setImageBitmap(bitmap);
return convertView;
}
class ViewHolder {
ImageView iv;
ViewHolder(View view) {
iv = view.findViewById(R.id.iv);
}
}
}
在MainActivity中初始化
ImageCache.getInstance().init(this,Environment.getExternalStorageDirectory()+"/dn");
我们第一次运行向下滑动直到底部,log打印输出从网络中获取,
我们再向上滑动,log打印输出从内存中获取,native内存也没有增长。、
我们关闭app后再打开,向下滑动,log打印输出从磁盘中获取
附源码本章源码