Android学习笔记_51_转android 加载大图片防止内存溢出

     首先来还原一下堆内存溢出的错误。首先在SD卡上放一张照片，分辨率为（3776 X 2520），大小为3.88MB，是我自己用相机拍的一张照片。应用的布局很简单，一个Button一个ImageView，然后按照常规的方式，使用BitmapFactory加载一张照片并使用一个ImageView展示。http://www.jb51.net/article/43462.htm

代码如下：

btn_loadimage.setOnClickListener(new View.OnClickListener() {



            @Override

            public void onClick(View v) {

                Bitmap bitmap=BitmapFactory.decodeFile("/sdcard/a.jpg");

                iv_bigimage.setImageBitmap(bitmap);

            }

}

 

当点击按钮后，程序会报错，查看日志为：

先来分析一下这个错误，首先dalvikvm（Android虚拟机）发现需要的内存38MB大于应用的堆内存24MB，这个时候尝试使用软加载的方式加载数据，我们知道当内存不足的时候dalvikvm会自动进行GC（Garbage Collection），大概清理了55k的空间出来，耗时203毫秒，但是内存还是不够，所以最后发生堆内存溢出的错误。

分析堆内存溢出

Android系统主要用于低能耗的移动设备，所以对内存的管理有很多限制，一个应用程序，Android系统缺省会为其分配最大16MB（某些机型是24MB）的空间作为堆内存空间，我这里使用的模拟器调试的，这个模拟器被设定为24MB，可以在Android Virtual Device Manager中查看到。

而这里的图片明明只有3.88MB，远远小于Android为应用分配的堆内存，而加载到内存中，为什么需要消耗大约38MB的内存呢？
我们都知道，图片是由一个一个点分布组成的（分辨率），通常加载这类数据都会在内存中创建一个二维数组，数组中的每一项代表一个点，而这个图片的分辨率是3776 * 2520，每一点又是由ARGB色组成，每个色素占4个Byte，所以这张图片加载到内存中需要消耗的内存为：
3776 * 2520 * 4byte = 38062080byte
大约需要38MB的内存才能正确加载这张图片，这就是上面错误描述需要38MB的内存空间，大小略有出入，因为图片还有一些Exif信息需要存储，会比仅靠分辨率计算要大一些。

如何加载大分辨率图片
有时候我们确实会需要加载一些大分辨率的图片，但是对于移动设备而言，哪怕加载能成功那么大的内存也是一种浪费(屏幕分辨率限制)，所以就需要想办法把图片按照一定比率压缩，使分辨率降低，以至于又不需要耗费很大的堆内存空间，又可以最大的利用设备屏幕的分辨率来显示图片。这里就用到一个BitmapFactory.Options对象，下面来介绍它。
BitmapFactory.Options为BitmapFactory的一个内部类，它主要用于设定与存储BitmapFactory加载图片的一些信息。下面是Options中需要用到的属性：
inJustDecodeBounds：如果设置为true，将不把图片的像素数组加载到内存中，仅加载一些额外的数据到Options中。
outHeight：图片的高度。
outWidth：图片的宽度。
inSampleSize：如果设置，图片将依据此采样率进行加载，不能设置为小于1的数。例如设置为4，分辨率宽和高将为原来的1/4，这个时候整体所占内存将是原来的1/16。

示例Demo

下面通过一个简单的Demo来演示上面提到的内容，代码中注释比较清晰，这里就不再累述了。

　　

package cn.bgxt.loadbigimg;

import android.os.Bundle;

import android.os.Environment;

import android.app.Activity;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.graphics.BitmapFactory.Options;

import android.view.Menu;

import android.view.View;

import android.view.WindowManager;

import android.widget.Button;

import android.widget.ImageView;

public class MainActivity extends Activity {

    private Button btn_loadimage;

    private ImageView iv_bigimage;

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

        btn_loadimage = (Button) findViewById(R.id.btn_loadimage);

        iv_bigimage = (ImageView) findViewById(R.id.iv_bigimage);

        btn_loadimage.setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                // Bitmap bitmap=BitmapFactory.decodeFile("/sdcard/a.jpg");

                // iv_bigimage.setImageBitmap(bitmap);

                BitmapFactory.Options opts = new Options();

                // 不读取像素数组到内存中，仅读取图片的信息

                opts.inJustDecodeBounds = true;

                BitmapFactory.decodeFile("/sdcard/a.jpg", opts);

                // 从Options中获取图片的分辨率

                int imageHeight = opts.outHeight;

                int imageWidth = opts.outWidth;

                // 获取Android屏幕的服务

                WindowManager wm = (WindowManager) getSystemService(WINDOW_SERVICE);

                // 获取屏幕的分辨率，getHeight()、getWidth已经被废弃掉了

                // 应该使用getSize()，但是这里为了向下兼容所以依然使用它们

                int windowHeight = wm.getDefaultDisplay().getHeight();

                int windowWidth = wm.getDefaultDisplay().getWidth();

                // 计算采样率

                int scaleX = imageWidth / windowWidth;

                int scaleY = imageHeight / windowHeight;

                int scale = 1;

                // 采样率依照最大的方向为准

                if (scaleX > scaleY && scaleY >= 1) {

                    scale = scaleX;

                }

                if (scaleX < scaleY && scaleX >= 1) {

                    scale = scaleY;

                }

                // false表示读取图片像素数组到内存中，依照设定的采样率

                opts.inJustDecodeBounds = false;

                // 采样率

                opts.inSampleSize = scale;

                Bitmap bitmap = BitmapFactory.decodeFile("/sdcard/a.jpg", opts);

                iv_bigimage.setImageBitmap(bitmap);

            }

        });

    }

}

效果展示：

总结
　　这里讲解了如何加载一个大分辨率的图片到内存中并使用它。不过一般好一点的图片处理软件，都会有图片放大功能，如果仅做此处理，单纯的把处理后的图片放大，会影响显示效果，图片还原度不高。一般会重新获取放大区域的图片的分辨率像素数组，然后重新处理加载到内存中进行显示。

------------------------------------------------分割线------------------------------------------------------------------------

尽量不要使用setImageBitmap或setImageResource或BitmapFactory.decodeResource来设置一张大图， 

因为这些函数在完成decode后，最终都是通过java层的createBitmap来完成的，需要消耗更多内存。 
因此，改用先通过BitmapFactory.decodeStream方法，创建出一个bitmap，再将其设为ImageView的 source， 
decodeStream最大的秘密在于其直接调用JNI>>nativeDecodeAsset()来完成decode， 
无需再使用java层的createBitmap，从而节省了java层的空间。 
如果在读取时加上图片的Config参数，可以跟有效减少加载的内存，从而跟有效阻止抛out of Memory异常 
另外，decodeStream直接拿的图片来读取字节码了， 不会根据机器的各种分辨率来自动适应， 
使用了decodeStream之后，需要在hdpi和mdpi，ldpi中配置相应的图片资源， 
否则在不同分辨率机器上都是同样大小（像素点数量），显示出来的大小就不对了。 
另外，以下方式也大有帮助： 
1. InputStream is = this.getResources().openRawResource(R.drawable.pic1); 
     BitmapFactory.Options options=new BitmapFactory.Options(); 
     options.inJustDecodeBounds = false; 
     options.inSampleSize = 10;   //width，hight设为原来的十分一 
     Bitmap btp =BitmapFactory.decodeStream(is,null,options); 
2. if(!bmp.isRecycle() ){ 
         bmp.recycle()   //回收图片所占的内存 
         system.gc()  //提醒系统及时回收 
} 
以下奉上一个方法： 
Java代码 
   1. /** 
   2.  * 以最省内存的方式读取本地资源的图片 
   3.  * @param context 
   4.  * @param resId 
   5.  * @return 
   6.  */  
   7. public static Bitmap readBitMap(Context context, int resId){  
   8.     BitmapFactory.Options opt = new BitmapFactory.Options();  
   9.     opt.inPreferredConfig = Bitmap.Config.RGB_565;   
  10.     opt.inPurgeable = true;  
  11.     opt.inInputShareable = true;  
  12.        //获取资源图片  
  13.     InputStream is = context.getResources().openRawResource(resId);  
  14.         return BitmapFactory.decodeStream(is,null,opt);  
  15. } 
================================================================================ 
Android内存溢出的解决办法 
转自：http://www.cppblog.com/iuranus/archive/2010/11/15/124394.html?opt=admin 
昨天在模拟器上给gallery放入图片的时候，出现java.lang.OutOfMemoryError: bitmap size exceeds VM budget 异常，图像大小超过了RAM内存。 
      模拟器RAM比较小，只有8M内存，当我放入的大量的图片（每个100多K左右），就出现上面的原因。 
由于每张图片先前是压缩的情况，放入到Bitmap的时候，大小会变大，导致超出RAM内存，具体解决办法如下： 
//解决加载图片 内存溢出的问题 
                    //Options 只保存图片尺寸大小，不保存图片到内存 
                BitmapFactory.Options opts = new BitmapFactory.Options(); 
                //缩放的比例，缩放是很难按准备的比例进行缩放的，其值表明缩放的倍数，SDK中建议其值是2的指数值,值越大会导致图片不清晰 
                opts.inSampleSize = 4; 
                Bitmap bmp = null; 
                bmp = BitmapFactory.decodeResource(getResources(), mImageIds[position],opts);                             
                ...              
               //回收 
                bmp.recycle(); 
通过上面的方式解决了，但是这并不是最完美的解决方式。 
通过一些了解，得知如下： 
优化Dalvik虚拟机的堆内存分配 
对于Android平台来说，其托管层使用的Dalvik Java VM从目前的表现来看还有很多地方可以优化处理，比如我们在开发一些大型游戏或耗资源的应用中可能考虑手动干涉GC处理，使用 dalvik.system.VMRuntime类提供的setTargetHeapUtilization方法可以增强程序堆内存的处理效率。当然具体原理我们可以参考开源工程，这里我们仅说下使用方法:   private final static float TARGET_HEAP_UTILIZATION = 0.75f; 在程序onCreate时就可以调用 VMRuntime.getRuntime().setTargetHeapUtilization(TARGET_HEAP_UTILIZATION); 即可。 
Android堆内存也可自己定义大小 
    对于一些Android项目，影响性能瓶颈的主要是Android自己内存管理机制问题，目前手机厂商对RAM都比较吝啬，对于软件的流畅性来说RAM对性能的影响十分敏感，除了 优化Dalvik虚拟机的堆内存分配外，我们还可以强制定义自己软件的对内存大小，我们使用Dalvik提供的 dalvik.system.VMRuntime类来设置最小堆内存为例: 
private final static int CWJ_HEAP_SIZE = 6* 1024* 1024 ; 
VMRuntime.getRuntime().setMinimumHeapSize(CWJ_HEAP_SIZE); //设置最小heap内存为6MB大小。当然对于内存吃紧来说还可以通过手动干涉GC去处理 
bitmap 设置图片尺寸，避免 内存溢出 OutOfMemoryError的优化方法 
★android 中用bitmap 时很容易内存溢出，报如下错误：Java.lang.OutOfMemoryError : bitmap size exceeds VM budget 
● 主要是加上这段： 
BitmapFactory.Options options = new BitmapFactory.Options(); 
                options.inSampleSize = 2; 
● eg1：(通过Uri取图片) 
private ImageView preview; 
BitmapFactory.Options options = new BitmapFactory.Options(); 
                    options.inSampleSize = 2;//图片宽高都为原来的二分之一，即图片为原来的四分之一 
                    Bitmap bitmap = BitmapFactory.decodeStream(cr 
                            .openInputStream(uri), null, options); 
                    preview.setImageBitmap(bitmap); 
以上代码可以优化内存溢出，但它只是改变图片大小，并不能彻底解决内存溢出。 
● eg2:（通过路径去图片） 
private ImageView preview; 
private String fileName= "/sdcard/DCIM/Camera/2010-05-14 16.01.44.jpg"; 
BitmapFactory.Options options = new BitmapFactory.Options(); 
                options.inSampleSize = 2;//图片宽高都为原来的二分之一，即图片为原来的四分之一 
                        Bitmap b = BitmapFactory.decodeFile(fileName, options); 
                        preview.setImageBitmap(b); 
                        filePath.setText(fileName); 
★Android 还有一些性能优化的方法： 
●  首先内存方面，可以参考 Android堆内存也可自己定义大小 和 优化Dalvik虚拟机的堆内存分配 
●  基础类型上，因为Java没有实际的指针，在敏感运算方面还是要借助NDK来完成。Android123提示游戏开发者，这点比较有意思的是Google 推出NDK可能是帮助游戏开发人员，比如OpenGL ES的支持有明显的改观，本地代码操作图形界面是很必要的。 
●  图形对象优化，这里要说的是Android上的Bitmap对象销毁，可以借助recycle()方法显示让GC回收一个Bitmap对象，通常对一个不用的Bitmap可以使用下面的方式，如 
if(bitmapObject.isRecycled()==false) //如果没有回收  
         bitmapObject.recycle();   
●  目前系统对动画支持比较弱智对于常规应用的补间过渡效果可以，但是对于游戏而言一般的美工可能习惯了GIF方式的统一处理，目前Android系统仅能预览GIF的第一帧，可以借助J2ME中通过线程和自己写解析器的方式来读取GIF89格式的资源。 
● 对于大多数Android手机没有过多的物理按键可能我们需要想象下了做好手势识别 GestureDetector 和重力感应来实现操控。通常我们还要考虑误操作问题的降噪处理。 
Android堆内存也可自己定义大小 
   对于一些大型Android项目或游戏来说在算法处理上没有问题外，影响性能瓶颈的主要是Android自己内存管理机制问题，目前手机厂商对RAM都比较吝啬，对于软件的流畅性来说RAM对性能的影响十分敏感，除了上次Android开发网提到的优化Dalvik虚拟机的堆内存分配外，我们还可以强制定义自己软件的对内存大小，我们使用Dalvik提供的 dalvik.system.VMRuntime类来设置最小堆内存为例: 
private final static int CWJ_HEAP_SIZE = 6* 1024* 1024 ; 
VMRuntime.getRuntime().setMinimumHeapSize(CWJ_HEAP_SIZE); //设置最小heap内存为6MB大小。当然对于内存吃紧来说还可以通过手动干涉GC去处理，我们将在下次提到具体应用。 
优化Dalvik虚拟机的堆内存分配 

对于Android平台来说，其托管层使用的Dalvik JavaVM从目前的表现来看还有很多地方可以优化处理，比如我们在开发一些大型游戏或耗资源的应用中可能考虑手动干涉GC处理，使用 dalvik.system.VMRuntime类提供的setTargetHeapUtilization方法可以增强程序堆内存的处理效率。当然具体原理我们可以参考开源工程，这里我们仅说下使用方法:   private final static floatTARGET_HEAP_UTILIZATION = 0.75f; 在程序onCreate时就可以调用 VMRuntime.getRuntime().setTargetHeapUtilization(TARGET_HEAP_UTILIZATION); 即可。

 

备注 ：之前在项目终于到内存溢出的问题，是在adapter的getView()操作的时候出现的，处理的方法是在获得图片的时候进行缩放处理，因为这些图片一直都要用，所以在onDestory()的时候进行回收。

 

参考：http://blog.csdn.net/zjl5211314/article/details/6679774

在开发图片浏览器等软件是，很多时候要显示图片的缩略图，而一般情况下，我们要将图片按照固定大小取缩略图，一般取缩略图的方法是使用BitmapFactory的decodeFile方法，然后通过传递进去 BitmapFactory.Options类型的参数进行取缩略图，在Option中，属性值inSampleSize表示缩略图大小为原始图片大小的几分之一，即如果这个值为2，则取出的缩略图的宽和高都是原始图片的1/2，图片大小就为原始大小的1/4。
　　然而，如果我们想取固定大小的缩略图就比较困难了，比如，我们想将不同大小的图片去出来的缩略图高度都为200px，而且要保证图片不失真，那怎么办?我们总不能将原始图片加载到内存中再进行缩放处理吧，要知道在移动开发中，内存是相当宝贵的，而且一张100K的图片，加载完所占用的内存何止 100K?
　　经过研究，发现，Options中有个属性inJustDecodeBounds，研究了一下，终于明白是什么意思了，SDK中的E文是这么说的
　　If set to true, the decoder will return null (no bitmap), but the out... fields will still be set, allowing the caller to query the bitmap without having to allocate the memory for its pixels.
　　意思就是说如果该值设为true那么将不返回实际的bitmap不给其分配内存空间而里面只包括一些解码边界信息即图片大小信息，那么相应的方法也就出来了，通过设置inJustDecodeBounds为true，获取到outHeight(图片原始高度)和 outWidth(图片的原始宽度)，然后计算一个inSampleSize(缩放值)，然后就可以取图片了，这里要注意的是，inSampleSize 可能小于0，必须做判断。
具体代码如下：
FrameLayout fr=(FrameLayout)findViewById(R.id.FrameLayout01);
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        // 获取这个图片的宽和高
        Bitmap bitmap = BitmapFactory.decodeFile("/sdcard/test.jpg", options);  //此时的bitmap为null
        options.inJustDecodeBounds = false;
         //计算缩放比
        int be = (int)(options.outHeight / (float)200);
        if (be <= 0)
            be = 1;
        options.inSampleSize = be;
        //重新读入图片，注意这次要把options.inJustDecodeBounds 设为 false
        bitmap=BitmapFactory.decodeFile("/sdcard/test.jpg",options);     //此时的bitmap不为null
        ImageView imageView=new ImageView(this);
        imageView.setImageBitmap(bitmap);
这样我们就可以读取较大的图片而不会内存溢出了。如果你想把压缩后的图片保存在Sdcard上的话就很简单了：
File file=new File("/sdcard/feng.png");
        try {
            FileOutputStream out=new FileOutputStream(file);
            if(bitmap.compress(Bitmap.CompressFormat.PNG, 100, out)){
                out.flush();
                out.close();
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
ok，这样就把图片保存在/sdcard/feng.png这个文件里面了， 
***********************************************************************************

转自http://www.cnblogs.com/RayLee/archive/2010/11/09/1872856.html

BitmapFactory.decodeFile(imageFile);

用BitmapFactory解码一张图片时，有时会遇到该错误。这往往是由于图片过大造成的。要想正常使用，则需要分配更少的内存空间来存储。

BitmapFactory.Options.inSampleSize

设置恰当的inSampleSize可以使BitmapFactory分配更少的空间以消除该错误。inSampleSize的具体含义请参考SDK文档。例如：

BitmapFactory.Options opts = new BitmapFactory.Options(); opts.inSampleSize = 4; Bitmap bitmap = BitmapFactory.decodeFile(imageFile, opts); 

设置恰当的inSampleSize是解决该问题的关键之一。BitmapFactory.Options提供了另一个成员inJustDecodeBounds。

BitmapFactory.Options opts = new BitmapFactory.Options(); opts.inJustDecodeBounds = true; Bitmap bitmap = BitmapFactory.decodeFile(imageFile, opts); 

 

 

设置inJustDecodeBounds为true后，decodeFile并不分配空间，但可计算出原始图片的长度和宽度，即options.outWidth和options.outHeight。有了这两个参数，再通过一定的算法，即可得到一个恰当的inSampleSize。

查看Android源码，Android提供了一种动态计算的方法。

 public static int computeSampleSize(BitmapFactory.Options options, int minSideLength, int maxNumOfPixels) {

 

int initialSize = computeInitialSampleSize(options, minSideLength, maxNumOfPixels);

int roundedSize;

 if (initialSize <= 8) {

 roundedSize = 1;

while (roundedSize < initialSize) {

 roundedSize <<= 1;

 }

} else {

roundedSize = (initialSize + 7) / 8 * 8;

}

return roundedSize;

}

private static int computeInitialSampleSize(BitmapFactory.Options options, int minSideLength, int maxNumOfPixels) {

double w = options.outWidth;

 double h = options.outHeight;

int lowerBound = (maxNumOfPixels == -1) ? 1 : (int) Math.ceil(Math.sqrt(w * h / maxNumOfPixels));

 int upperBound = (minSideLength == -1) ? 128 : (int) Math.min(Math.floor(w / minSideLength), Math.floor(h / minSideLength));

 if (upperBound < lowerBound) {

// return the larger one when there is no overlapping zone.

return lowerBound;

}

 if ((maxNumOfPixels == -1) && (minSideLength == -1)) {

return 1;

} else if (minSideLength == -1) {

return lowerBound;

 } else {

 return upperBound;

 }

}

 

另外，可以通过Bitmap.recycle()方法来释放位图所占的空间，当然前提是位图没有被使用。