关闭

Android 那些你所不知道的Bitmap对象详解(转)

195人阅读 评论(0) 收藏 举报
分类:

转载请注明本文出自xiaanming的博客(http://blog.csdn.net/xiaanming/article/details/41084843),请尊重他人的辛勤劳动成果,谢谢!

我们知道Android系统分配给每个应用程序的内存是有限的,Bitmap作为消耗内存大户,我们对Bitmap的管理稍有不当就可能引发OutOfMemoryError,而Bitmap对象在不同的Android版本中存在一些差异,今天就给大家介绍下这些差异,并提供一些在使用Bitmap的需要注意的地方。

在Android2.3.3(API 10)及之前的版本中,Bitmap对象与其像素数据是分开存储的,Bitmap对象存储在Dalvik heap中,而Bitmap对象的像素数据则存储在Native Memory(本地内存)中或者说Derict Memory(直接内存)中,这使得存储在Native Memory中的像素数据的释放是不可预知的,我们可以调用recycle()方法来对Native Memory中的像素数据进行释放,前提是你可以清楚的确定Bitmap已不再使用了,如果你调用了Bitmap对象recycle()之后再将Bitmap绘制出来,就会出现"Canvas: trying to use a recycled bitmap"错误,而在Android3.0(API 11)之后,Bitmap的像素数据和Bitmap对象一起存储在Dalvik heap中,所以我们不用手动调用recycle()来释放Bitmap对象,内存的释放都交给垃圾回收器来做,也许你会问,为什么我在显示Bitmap对象的时候还是会出现OutOfMemoryError呢?

在说这个问题之前我顺便提一下,在Android2.2(API 8)之前,使用的是Serial垃圾收集器,从名字可以看出这是一个单线程的收集器,这里的”单线程"的意思并不仅仅是使用一个CPU或者一条收集线程去收集垃圾,更重要的是在它进行垃圾收集时,必须暂停其他所有的工作线程,Android2.3之后,这种收集器就被代替了,使用的是并发的垃圾收集器,这意味着我们的垃圾收集线程和我们的工作线程互不影响。

简单的了解垃圾收集器之后,我们对上面的问题举一个简单的例子,假如系统启动了垃圾回收线程去收集垃圾,而此时我们一下子产生大量的Bitmap对象,此时是有可能会产生OutOfMemoryError,因为垃圾回收器首先要判断某个对象是否还存活(JAVA语言判断对象是否存活使用的是根搜索算法 GC Root Tracing),然后利用垃圾回收算法来对垃圾进行回收,不同的垃圾回收器具有不同的回收算法,这些都是需要时间的, 发生OutOfMemoryError的时候,我们要明确到底是因为内存泄露(Memory Leak)引发的还是内存溢出(Memory overflow)引发的,如果是内存泄露我们需要利用工具(比如MAT)查明内存泄露的代码并进行改正,如果不存在泄露,换句话来说就是内存中的对象确实还必须活着,那我们可以看看是否可以通过某种途径,减少对象对内存的消耗,比如我们在使用Bitmap的时候,应该根据View的大小利用BitmapFactory.Options计算合适的inSimpleSize来对Bitmap进行相对应的裁剪,以减少Bitmap对内存的使用,如果上面都做好了还是存在OutOfMemoryError(一般这种情况很少发生)的话,那我们只能调大Dalvik heap的大小了,在Android 3.1以及更高的版本中,我们可以在AndroidManifest.xml的application标签中增加一个值等于“true”的android:largeHeap属性来通知Dalvik虚拟机应用程序需要使用较大的Java Heap,但是我们也不鼓励这么做。


在Android 2.3及以下管理Bitmap

从上面我们知道,在Android2.3及以下我们推荐使用recycle()方法来释放内存,我们在使用ListView或者GridView的时候,该在什么时候去调用recycle()呢?这里我们用到引用计数,使用一个变量(dispalyRefCount)来记录Bitmap显示情况,如果Bitmap绘制在View上面displayRefCount加一, 否则就减一, 只有在displayResCount为0且Bitmap不为空且Bitmap没有调用过recycle()的时候,我们才需求对该Bitmap对象进行recycle(),所以我们需要用一个类来包装下Bitmap对象,代码如下

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. package com.example.bitmap;  
  2.   
  3. import android.content.res.Resources;  
  4. import android.graphics.Bitmap;  
  5. import android.graphics.drawable.BitmapDrawable;  
  6.   
  7. public class RecycleBitmapDrawable extends BitmapDrawable {  
  8.     private int displayResCount = 0;  
  9.     private boolean mHasBeenDisplayed;  
  10.   
  11.     public RecycleBitmapDrawable(Resources res, Bitmap bitmap) {  
  12.         super(res, bitmap);  
  13.     }  
  14.       
  15.       
  16.     /** 
  17.      * @param isDisplay 
  18.      */  
  19.     public void setIsDisplayed(boolean isDisplay){  
  20.         synchronized (this) {  
  21.             if(isDisplay){  
  22.                 mHasBeenDisplayed = true;  
  23.                 displayResCount ++;  
  24.             }else{  
  25.                 displayResCount --;  
  26.             }  
  27.         }  
  28.           
  29.         checkState();  
  30.           
  31.     }  
  32.       
  33.     /** 
  34.      * 检查图片的一些状态,判断是否需要调用recycle 
  35.      */  
  36.     private synchronized void checkState() {  
  37.         if (displayResCount <= 0 && mHasBeenDisplayed  
  38.                 && hasValidBitmap()) {  
  39.             getBitmap().recycle();  
  40.         }  
  41.     }  
  42.       
  43.       
  44.     /** 
  45.      * 判断Bitmap是否为空且是否调用过recycle() 
  46.      * @return 
  47.      */  
  48.     private synchronized boolean hasValidBitmap() {  
  49.         Bitmap bitmap = getBitmap();  
  50.         return bitmap != null && !bitmap.isRecycled();  
  51.     }  
  52.   
  53. }  
除了上面这个RecycleBitmapDrawable之外呢,我们还需要一个自定义的ImageView来控制什么时候显示Bitmap以及什么时候隐藏Bitmap对象

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. package com.example.bitmap;  
  2.   
  3. import android.content.Context;  
  4. import android.graphics.drawable.Drawable;  
  5. import android.graphics.drawable.LayerDrawable;  
  6. import android.util.AttributeSet;  
  7. import android.widget.ImageView;  
  8.   
  9. public class RecycleImageView extends ImageView {  
  10.     public RecycleImageView(Context context) {  
  11.         super(context);  
  12.     }  
  13.   
  14.     public RecycleImageView(Context context, AttributeSet attrs) {  
  15.         super(context, attrs);  
  16.     }  
  17.   
  18.     public RecycleImageView(Context context, AttributeSet attrs, int defStyle) {  
  19.         super(context, attrs, defStyle);  
  20.     }  
  21.   
  22.     @Override  
  23.     public void setImageDrawable(Drawable drawable) {  
  24.         Drawable previousDrawable = getDrawable();  
  25.         super.setImageDrawable(drawable);  
  26.           
  27.         //显示新的drawable  
  28.         notifyDrawable(drawable, true);  
  29.   
  30.         //回收之前的图片  
  31.         notifyDrawable(previousDrawable, false);  
  32.     }  
  33.   
  34.     @Override  
  35.     protected void onDetachedFromWindow() {  
  36.         //当View从窗口脱离的时候,清除drawable  
  37.         setImageDrawable(null);  
  38.   
  39.         super.onDetachedFromWindow();  
  40.     }  
  41.   
  42.     /** 
  43.      * 通知该drawable显示或者隐藏 
  44.      *  
  45.      * @param drawable 
  46.      * @param isDisplayed 
  47.      */  
  48.     public static void notifyDrawable(Drawable drawable, boolean isDisplayed) {  
  49.         if (drawable instanceof RecycleBitmapDrawable) {  
  50.             ((RecycleBitmapDrawable) drawable).setIsDisplayed(isDisplayed);  
  51.         } else if (drawable instanceof LayerDrawable) {  
  52.             LayerDrawable layerDrawable = (LayerDrawable) drawable;  
  53.             for (int i = 0, z = layerDrawable.getNumberOfLayers(); i < z; i++) {  
  54.                 notifyDrawable(layerDrawable.getDrawable(i), isDisplayed);  
  55.             }  
  56.         }  
  57.     }  
  58.   
  59. }  
这个自定类也比较简单,重写了setImageDrawable()方法,在这个方法中我们先获取ImageView上面的图片,然后通知之前显示在ImageView的Drawable不在显示了,Drawable会判断是否需要调用recycle(),当View从Window脱离的时候会回调onDetachedFromWindow(),我们在这个方法中回收显示在ImageView的图片,具体的使用方法

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. ImageView imageView = new ImageView(context);  
  2.         imageView.setImageDrawable(new RecycleBitmapDrawable(context.getResource(), bitmap));  
只需要用RecycleBitmapDrawable包装Bitmap对象,然后设置到ImageView上面就可以啦,具体的内存释放我们不需要管,是不是很方便呢?这是在Android2.3以及以下的版本管理Bitmap的内存。


在Android 3.0及以上管理Bitmap

由于在Android3.0及以上的版本中,Bitmap的像素数据也存储在Dalvik heap中,所以内存的管理就直接交给垃圾回收器了,我们并不需要手动的去释放内存,而今天讲的主要是BitmapFactory.Options.inBitmap的这个字段,假如这个字段被设置了,我们在解码Bitmap的时候,他会去重用inBitmap设置的Bitmap,减少内存的分配和释放,提高了应用的性能,然而在Android 4.4之前,BitmapFactory.Options.inBitmap设置的Bitmap必须和我们需要解码的Bitmap的大小一致才行,在Android4.4以后,BitmapFactory.Options.inBitmap设置的Bitmap大于或者等于我们需要解码的Bitmap的大小就OK了,我们先假设一个场景,还是在使用ListView,GridView去加载大量的图片,为了提高应用的效率,我们通常会做相对应的内存缓存和硬盘缓存,这里我们只说内存缓存,而内存缓存官方推荐使用LruCache, 注意LruCache只是起到缓存数据作用,并没有回收内存。一般我们的代码会这么写

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. package com.example.bitmap;  
  2.   
  3. import java.lang.ref.SoftReference;  
  4. import java.util.Collections;  
  5. import java.util.HashSet;  
  6. import java.util.Iterator;  
  7. import java.util.Set;  
  8.   
  9. import android.annotation.TargetApi;  
  10. import android.graphics.Bitmap;  
  11. import android.graphics.Bitmap.Config;  
  12. import android.graphics.BitmapFactory;  
  13. import android.graphics.drawable.BitmapDrawable;  
  14. import android.os.Build;  
  15. import android.os.Build.VERSION_CODES;  
  16. import android.support.v4.util.LruCache;  
  17.   
  18. public class ImageCache {  
  19.     private final static int MAX_MEMORY = 4 * 102 * 1024;  
  20.     private LruCache<String, BitmapDrawable> mMemoryCache;  
  21.   
  22.     private Set<SoftReference<Bitmap>> mReusableBitmaps;  
  23.   
  24.     private void init() {  
  25.         if (hasHoneycomb()) {  
  26.             mReusableBitmaps = Collections  
  27.                     .synchronizedSet(new HashSet<SoftReference<Bitmap>>());  
  28.         }  
  29.   
  30.         mMemoryCache = new LruCache<String, BitmapDrawable>(MAX_MEMORY) {  
  31.   
  32.             /** 
  33.              * 当保存的BitmapDrawable对象从LruCache中移除出来的时候回调的方法 
  34.              */  
  35.             @Override  
  36.             protected void entryRemoved(boolean evicted, String key,  
  37.                     BitmapDrawable oldValue, BitmapDrawable newValue) {  
  38.   
  39.                 if (hasHoneycomb()) {  
  40.                     mReusableBitmaps.add(new SoftReference<Bitmap>(oldValue  
  41.                             .getBitmap()));  
  42.                 }  
  43.             }  
  44.   
  45.         };  
  46.     }  
  47.   
  48.       
  49.     /** 
  50.      * 从mReusableBitmaps中获取满足 能设置到BitmapFactory.Options.inBitmap上面的Bitmap对象 
  51.      * @param options 
  52.      * @return 
  53.      */  
  54.     protected Bitmap getBitmapFromReusableSet(BitmapFactory.Options options) {  
  55.         Bitmap bitmap = null;  
  56.   
  57.         if (mReusableBitmaps != null && !mReusableBitmaps.isEmpty()) {  
  58.             synchronized (mReusableBitmaps) {  
  59.                 final Iterator<SoftReference<Bitmap>> iterator = mReusableBitmaps  
  60.                         .iterator();  
  61.                 Bitmap item;  
  62.   
  63.                 while (iterator.hasNext()) {  
  64.                     item = iterator.next().get();  
  65.   
  66.                     if (null != item && item.isMutable()) {  
  67.                         if (canUseForInBitmap(item, options)) {  
  68.                             bitmap = item;  
  69.                             iterator.remove();  
  70.                             break;  
  71.                         }  
  72.                     } else {  
  73.                         iterator.remove();  
  74.                     }  
  75.                 }  
  76.             }  
  77.         }  
  78.         return bitmap;  
  79.     }  
  80.   
  81.     /** 
  82.      * 判断该Bitmap是否可以设置到BitmapFactory.Options.inBitmap上 
  83.      *  
  84.      * @param candidate 
  85.      * @param targetOptions 
  86.      * @return 
  87.      */  
  88.     @TargetApi(VERSION_CODES.KITKAT)  
  89.     public static boolean canUseForInBitmap(Bitmap candidate,  
  90.             BitmapFactory.Options targetOptions) {  
  91.   
  92.         // 在Anroid4.4以后,如果要使用inBitmap的话,只需要解码的Bitmap比inBitmap设置的小就行了,对inSampleSize  
  93.         // 没有限制  
  94.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {  
  95.             int width = targetOptions.outWidth / targetOptions.inSampleSize;  
  96.             int height = targetOptions.outHeight / targetOptions.inSampleSize;  
  97.             int byteCount = width * height  
  98.                     * getBytesPerPixel(candidate.getConfig());  
  99.             return byteCount <= candidate.getAllocationByteCount();  
  100.         }  
  101.   
  102.         // 在Android  
  103.         // 4.4之前,如果想使用inBitmap的话,解码的Bitmap必须和inBitmap设置的宽高相等,且inSampleSize为1  
  104.         return candidate.getWidth() == targetOptions.outWidth  
  105.                 && candidate.getHeight() == targetOptions.outHeight  
  106.                 && targetOptions.inSampleSize == 1;  
  107.     }  
  108.   
  109.     /** 
  110.      * 获取每个像素所占用的Byte数 
  111.      *  
  112.      * @param config 
  113.      * @return 
  114.      */  
  115.     public static int getBytesPerPixel(Config config) {  
  116.         if (config == Config.ARGB_8888) {  
  117.             return 4;  
  118.         } else if (config == Config.RGB_565) {  
  119.             return 2;  
  120.         } else if (config == Config.ARGB_4444) {  
  121.             return 2;  
  122.         } else if (config == Config.ALPHA_8) {  
  123.             return 1;  
  124.         }  
  125.         return 1;  
  126.     }  
  127.   
  128.     @TargetApi(VERSION_CODES.HONEYCOMB)  
  129.     public static boolean hasHoneycomb() {  
  130.         return Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB;  
  131.     }  
  132.   
  133. }  
上面只是一些事例性的代码,将从LruCache中移除的BitmapDrawable对象的弱引用保存在一个set中,然后从set中获取满足BitmapFactory.Options.inBitmap条件的Bitmap对象用来提高解码Bitmap性能,使用如下

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. public static Bitmap decodeSampledBitmapFromFile(String filename,  
  2.             int reqWidth, int reqHeight) {  
  3.   
  4.         final BitmapFactory.Options options = new BitmapFactory.Options();  
  5.         ...  
  6.         BitmapFactory.decodeFile(filename, options);  
  7.         ...  
  8.   
  9.         // If we're running on Honeycomb or newer, try to use inBitmap.  
  10.         if (ImageCache.hasHoneycomb()) {  
  11.              options.inMutable = true;  
  12.   
  13.                 if (cache != null) {  
  14.                     Bitmap inBitmap = cache.getBitmapFromReusableSet(options);  
  15.   
  16.                     if (inBitmap != null) {  
  17.                         options.inBitmap = inBitmap;  
  18.                     }  
  19.                 }  
  20.         }  
  21.         ...  
  22.         return BitmapFactory.decodeFile(filename, options);  
  23.     }  

通过这篇文章你是不是对Bitmap对象有了更进一步的了解,在应用加载大量的Bitmap对象的时候,如果你做到上面几点,我相信应用发生OutOfMemoryError的概率会很小,并且性能会得到一定的提升,我经常会看到一些同学在评价一个图片加载框架好不好的时候,比较片面的以自己使用过程中是否发生OutOfMemoryError来定论,当然经常性的发生OutOfMemoryError你应该先检查你的代码是否存在问题,一般一些比较成熟的框架是不存在很严重的问题,毕竟它也经过很多的考验才被人熟知的,今天的讲解就到这里了,有疑问的同学可以在下面留言!

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:8336次
    • 积分:167
    • 等级:
    • 排名:千里之外
    • 原创:2篇
    • 转载:41篇
    • 译文:0篇
    • 评论:2条
    文章分类
    最新评论