将图像加载到 Bitmap 对象时出现奇怪的 OutOfMemory 问题

Question

我有一个 ListView，每行都有几个图像按钮。 当用户单击列表行时，它会启动一个新活动。 由于相机布局问题，我不得不构建自己的选项卡。 针对结果启动的活动是地图。 如果我单击按钮启动图像预览（从 SD 卡加载图像），应用程序将从活动返回到结果处理程序的 ListView 活动以重新启动我的新活动，这没什么不仅仅是一个图像小部件。

ListView 上的图像预览是通过光标和 ListAdapter 完成的。 这使得它非常简单，但我不确定如何放置调整大小的图像（即较小的位大小而不是像素作为动态图像按钮的 src 。所以我只是调整了图像的大小 有

问题是当它尝试返回并重新启动第二个活动时，我收到一个 OutOfMemoryError ，

• 没有一种方法可以轻松地逐行构建列表适配器，我可以在哪里动态调整大小（按位）？

这会更好，因为我还需要对每行中的小部件/元素的属性进行一些更改，因为我无法选择一行由于焦点问题，触摸屏（我可以使用滚球。）

• 我知道我可以进行带外调整大小并保存图像，但这并不是我真正想要做的，但是 这

一旦我禁用了 ListView 上的图像，它就会再次正常工作：

就是我的做法：

String[] from = new String[] { DBHelper.KEY_BUSINESSNAME, DBHelper.KEY_ADDRESS,
    DBHelper.KEY_CITY, DBHelper.KEY_GPSLONG, DBHelper.KEY_GPSLAT,
    DBHelper.KEY_IMAGEFILENAME  + ""};
int[] to = new int[] { R.id.businessname, R.id.address, R.id.city, R.id.gpslong,
    R.id.gpslat, R.id.imagefilename };
notes = new SimpleCursorAdapter(this, R.layout.notes_row, c, from, to);
setListAdapter(notes);

其中 R.id.imagefilename 。 是一个ButtonImage。

这是我的 LogCat：

01-25 05:05:49.877: ERROR/dalvikvm-heap(3896): 6291456-byte external allocation too large for this process.
01-25 05:05:49.877: ERROR/(3896): VM wont let us allocate 6291456 bytes
01-25 05:05:49.877: ERROR/AndroidRuntime(3896): Uncaught handler: thread main exiting due to uncaught exception
01-25 05:05:49.917: ERROR/AndroidRuntime(3896): java.lang.OutOfMemoryError: bitmap size exceeds VM budget
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.graphics.BitmapFactory.nativeDecodeStream(Native Method)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.graphics.BitmapFactory.decodeStream(BitmapFactory.java:304)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.graphics.BitmapFactory.decodeFile(BitmapFactory.java:149)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.graphics.BitmapFactory.decodeFile(BitmapFactory.java:174)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.graphics.drawable.Drawable.createFromPath(Drawable.java:729)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.widget.ImageView.resolveUri(ImageView.java:484)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.widget.ImageView.setImageURI(ImageView.java:281)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.widget.SimpleCursorAdapter.setViewImage(SimpleCursorAdapter.java:183)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.widget.SimpleCursorAdapter.bindView(SimpleCursorAdapter.java:129)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.widget.CursorAdapter.getView(CursorAdapter.java:150)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.widget.AbsListView.obtainView(AbsListView.java:1057)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.widget.ListView.makeAndAddView(ListView.java:1616)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.widget.ListView.fillSpecific(ListView.java:1177)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.widget.ListView.layoutChildren(ListView.java:1454)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.widget.AbsListView.onLayout(AbsListView.java:937)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.view.View.layout(View.java:5611)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.widget.LinearLayout.setChildFrame(LinearLayout.java:1119)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.widget.LinearLayout.layoutHorizontal(LinearLayout.java:1108)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.widget.LinearLayout.onLayout(LinearLayout.java:922)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.view.View.layout(View.java:5611)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.widget.FrameLayout.onLayout(FrameLayout.java:294)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.view.View.layout(View.java:5611)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.widget.LinearLayout.setChildFrame(LinearLayout.java:1119)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.widget.LinearLayout.layoutVertical(LinearLayout.java:999)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.widget.LinearLayout.onLayout(LinearLayout.java:920)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.view.View.layout(View.java:5611)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.widget.FrameLayout.onLayout(FrameLayout.java:294)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.view.View.layout(View.java:5611)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.view.ViewRoot.performTraversals(ViewRoot.java:771)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.view.ViewRoot.handleMessage(ViewRoot.java:1103)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.os.Handler.dispatchMessage(Handler.java:88)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.os.Looper.loop(Looper.java:123)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at android.app.ActivityThread.main(ActivityThread.java:3742)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at java.lang.reflect.Method.invokeNative(Native Method)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at java.lang.reflect.Method.invoke(Method.java:515)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:739)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:497)
01-25 05:05:49.917: ERROR/AndroidRuntime(3896):     at dalvik.system.NativeStart.main(Native Method)
01-25 05:10:01.127: ERROR/AndroidRuntime(3943): ERROR: thread attach failed 

显示图像时我也遇到了新错误：

22:13:18.594: DEBUG/skia(4204): xxxxxxxxxxx jpeg error 20 Improper call to JPEG library in state %d
22:13:18.604: INFO/System.out(4204): resolveUri failed on bad bitmap uri: 
22:13:18.694: ERROR/dalvikvm-heap(4204): 6291456-byte external allocation too large for this process.
22:13:18.694: ERROR/(4204): VM won't let us allocate 6291456 bytes
22:13:18.694: DEBUG/skia(4204): xxxxxxxxxxxxxxxxxxxx allocPixelRef failed

Answer 1

我有 iOS 经验，当我发现像加载和显示图像这样基本的问题时，我感到很沮丧。 毕竟，遇到此问题的每个人都在尝试显示合理大小的图像。 无论如何，这里有两个更改解决了我的问题（并使我的应用程序响应非常灵敏）。

1) 每次执行 BitmapFactory.decodeXYZ() 时，请确保传入 BitmapFactory.Options 并将 inPurgeable 设置为 true （最好将 inInputShareable 也设置为 true）。

2) 切勿使用 Bitmap.createBitmap(width, height, Config.ARGB_8888)。 我的意思是永远不会！ 我从来没有遇到过在几次通过后不会引发内存错误的情况。 再多的recycle()、System.gc()，无论有什么帮助。 它总是引发异常。 另一种实际有效的方法是在可绘制对象中放置一个虚拟图像（或使用上面步骤 1 解码的另一个位图），将其重新缩放为您想要的任何大小，然后操作生成的位图（例如将其传递到 Canvas）为了更多乐趣）。 因此，您应该使用：Bitmap.createScaledBitmap(srcBitmap, width, height, false)。 如果出于某种原因您必须使用暴力创建方法，那么至少要传递 Config.ARGB_4444。

这几乎可以保证为您节省数小时甚至数天的时间。 所有关于缩放图像等的讨论都不起作用（除非您考虑使用错误的尺寸或降级图像作为解决方案）。

Answer 2

这是一个已知错误，并不是因为文件太大。 由于 Android 缓存了 Drawable，因此在使用少量图像后就会出现内存不足的情况。 但我找到了另一种方法，跳过 android 默认缓存系统。

解决方案：
将图像移动到“assets”文件夹并使用以下函数获取 BitmapDrawable：

public static Drawable getAssetImage(Context context, String filename) throws IOException {
    AssetManager assets = context.getResources().getAssets();
    InputStream buffer = new BufferedInputStream((assets.open("drawable/" + filename + ".png")));
    Bitmap bitmap = BitmapFactory.decodeStream(buffer);
    return new BitmapDrawable(context.getResources(), bitmap);
}

Answer 3

我遇到了同样的问题，并通过避免使用 BitmapFactory.decodeStream 或decodeFile 函数来解决它，而是使用 BitmapFactory.decodeFileDescriptor

decodeFileDescriptor 看起来它调用的本机方法与decodeStream/decodeFile 不同。

无论如何，有效的是这个（请注意，我添加了一些选项，如上面的一些选项，但这并不是造成差异的原因。关键是调用 BitmapFactory.decodeFileDescriptor 而不是 decodeStream< /strong> 或 decodeFile)：

private void showImage(String path)   {

    Log.i("showImage","loading:"+path);
    BitmapFactory.Options bfOptions=new BitmapFactory.Options();
    bfOptions.inDither=false;                     //Disable Dithering mode
    bfOptions.inPurgeable=true;                   //Tell to gc that whether it needs free memory, the Bitmap can be cleared
    bfOptions.inInputShareable=true;              //Which kind of reference will be used to recover the Bitmap data after being clear, when it will be used in the future
    bfOptions.inTempStorage=new byte[32 * 1024]; 

    File file=new File(path);
    FileInputStream fs=null;
    try {
        fs = new FileInputStream(file);
    } catch (FileNotFoundException e) {
        //TODO do something intelligent
        e.printStackTrace();
    }

    try {
        if(fs!=null) bm=BitmapFactory.decodeFileDescriptor(fs.getFD(), null, bfOptions);
    } catch (IOException e) {
        //TODO do something intelligent
        e.printStackTrace();
    } finally{ 
        if(fs!=null) {
            try {
                fs.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
    //bm=BitmapFactory.decodeFile(path, bfOptions); This one causes error: java.lang.OutOfMemoryError: bitmap size exceeds VM budget

    im.setImageBitmap(bm);
    //bm.recycle();
    bm=null;                        
}

我认为decodeStream/decodeFile 中使用的本机函数有问题。 我已经确认使用decodeFileDescriptor 时会调用不同的本机方法。 另外，我读到的是“图像（位图）不是以标准 Java 方式分配的，而是通过本机调用分配的；分配是在虚拟堆之外完成的，但
算作反对它！”

Answer 4

我认为避免 OutOfMemoryError 的最佳方法是面对它并理解它。

我制作了一个应用来故意引发OutOfMemoryError，并监视内存使用情况。

在我对这个App做了很多实验之后，我得到了以下结论：

我先谈谈Honey Comb之前的SDK版本。

1. Bitmap 存储在本机堆中，但会自动进行垃圾回收，无需调用 recycle()。

2. 如果 {VM 堆大小} + {分配的本机堆内存} >= {设备的 VM 堆大小限制}，并且您尝试创建位图，则会抛出 OOM。

   注意：计算的是 VM HEAP SIZE，而不是 VM ALLOCATED MEMORY。

3. 即使分配的虚拟机内存缩小，虚拟机堆大小在增长后也永远不会缩小。

4. 因此，您必须将峰值 VM 内存保持得尽可能低，以防止 VM 堆大小变得太大而无法节省位图的可用内存。

   因此，

5. 手动调用 System.gc() 是没有意义的，系统会在尝试增加堆大小之前先调用它。

6. Native Heap Size 永远不会缩小，但不计入 OOM，因此无需担心。

   Native Heap Size 永远不会缩小

那么，我们来谈谈SDK是从Honey Comb开始的。

1. 位图存储在VM堆中，本机内存不计入OOM。

2. OOM 的条件要简单得多：{VM 堆大小} >= {设备的 VM 堆大小限制}。

3. 因此，您有更多的可用内存来创建具有相同堆大小限制的位图，抛出 OOM 的可能性较小。

   因此，您有更多的可用内存来创建具有

以下是我对垃圾收集和内存泄漏的一些观察。

你可以自己在App中看到。 如果一个 Activity 执行了一个在该 Activity 被销毁后仍在运行的 AsyncTask，则该 Activity 在 AsyncTask 完成之前不会被垃圾回收。

这是因为AsyncTask是一个匿名内部类的实例，它保存了Activity的引用。

如果任务在后台线程的 IO 操作中被阻塞，调用 AsyncTask.cancel(true) 不会停止执行。

回调也是匿名内部类，因此如果项目中的静态实例保留它们并且不释放它们，则会泄漏内存。

如果您安排了重复或延迟的任务，例如计时器，并且您没有在 onPause() 中调用 cancel() 和 purge()，则内存将会泄漏。

Answer 5

最近看到很多关于OOM异常和缓存的问题。 开发人员指南对此有一篇非常好的文章，但有些往往无法以适当的方式实施它。

因此，我编写了一个示例应用程序来演示 Android 环境中的缓存。 此实现尚未出现 OOM。

查看此答案的末尾以获取源代码的链接。

要求：

• Android API 2.1 或更高版本（我根本无法在 API 1.6 中获取应用程序的可用内存 - 这是唯一在 API 1.6 中不起作用的代码）
• Android 支持包

功能：

• 在方向发生变化时保留缓存，使用单例
• 将分配的应用程序内存的八分之一用于缓存（如果需要，可以修改）
• 大位图进行缩放（您可以定义要允许的最大像素）
• 在下载位图之前控制是否有可用的互联网连接
• 确保您仅实例化每行一个任务
• 如果您将ListView 甩开，它根本不会下载之间的位图。

这不包括：

• 磁盘缓存。 无论如何，这应该很容易实现 - 只需指向从磁盘获取位图的不同任务

示例代码：

正在下载的图像是来自 Flickr 的图像 (75x75)。 但是，输入您想要处理的任何图像网址，如果超过最大值，应用程序会将其缩小。 在此应用程序中，网址仅位于 String 数组中。

LruCache 有一个很好的方法来处理与位图。 但是，在此应用程序中，我将 LruCache 的实例放入我创建的另一个缓存类中，以使应用程序更加可行。

Cache.java 的关键内容（loadBitmap() 方法是最重要的）：

public Cache(int size, int maxWidth, int maxHeight) {
    // Into the constructor you add the maximum pixels
    // that you want to allow in order to not scale images.
    mMaxWidth = maxWidth;
    mMaxHeight = maxHeight;

    mBitmapCache = new LruCache<String, Bitmap>(size) {
        protected int sizeOf(String key, Bitmap b) {
            // Assuming that one pixel contains four bytes.
            return b.getHeight() * b.getWidth() * 4;
        }
    };

    mCurrentTasks = new ArrayList<String>();    
}

/**
 * Gets a bitmap from cache. 
 * If it is not in cache, this method will:
 * 
 * 1: check if the bitmap url is currently being processed in the
 * BitmapLoaderTask and cancel if it is already in a task (a control to see
 * if it's inside the currentTasks list).
 * 
 * 2: check if an internet connection is available and continue if so.
 * 
 * 3: download the bitmap, scale the bitmap if necessary and put it into
 * the memory cache.
 * 
 * 4: Remove the bitmap url from the currentTasks list.
 * 
 * 5: Notify the ListAdapter.
 * 
 * @param mainActivity - Reference to activity object, in order to
 * call notifyDataSetChanged() on the ListAdapter.
 * @param imageKey - The bitmap url (will be the key).
 * @param imageView - The ImageView that should get an
 * available bitmap or a placeholder image.
 * @param isScrolling - If set to true, we skip executing more tasks since
 * the user probably has flinged away the view.
 */
public void loadBitmap(MainActivity mainActivity, 
        String imageKey, ImageView imageView,
        boolean isScrolling) {
    final Bitmap bitmap = getBitmapFromCache(imageKey); 

    if (bitmap != null) {
        imageView.setImageBitmap(bitmap);
    } else {
        imageView.setImageResource(R.drawable.ic_launcher);
        if (!isScrolling && !mCurrentTasks.contains(imageKey) && 
                mainActivity.internetIsAvailable()) {
            BitmapLoaderTask task = new BitmapLoaderTask(imageKey,
                    mainActivity.getAdapter());
            task.execute();
        }
    } 
}

您不需要编辑 Cache.java 文件中的任何内容，除非您想实现磁盘缓存。

MainActivity.java 的关键内容：

public void onScrollStateChanged(AbsListView view, int scrollState) {
    if (view.getId() == android.R.id.list) {
        // Set scrolling to true only if the user has flinged the       
        // ListView away, hence we skip downloading a series
        // of unnecessary bitmaps that the user probably
        // just want to skip anyways. If we scroll slowly it
        // will still download bitmaps - that means
        // that the application won't wait for the user
        // to lift its finger off the screen in order to
        // download.
        if (scrollState == SCROLL_STATE_FLING) {
            mIsScrolling = true;
        } else {
            mIsScrolling = false;
            mListAdapter.notifyDataSetChanged();
        }
    } 
}

// Inside ListAdapter...
@Override
public View getView(final int position, View convertView, ViewGroup parent) {           
    View row = convertView;
    final ViewHolder holder;

    if (row == null) {
        LayoutInflater inflater = getLayoutInflater();
        row = inflater.inflate(R.layout.main_listview_row, parent, false);  
        holder = new ViewHolder(row);
        row.setTag(holder);
    } else {
        holder = (ViewHolder) row.getTag();
    }   

    final Row rowObject = getItem(position);

    // Look at the loadBitmap() method description...
    holder.mTextView.setText(rowObject.mText);      
    mCache.loadBitmap(MainActivity.this,
            rowObject.mBitmapUrl, holder.mImageView,
            mIsScrolling);  

    return row;
}

getView() 被频繁调用。 如果我们没有实施检查来确保我们不会在每行启动无限数量的线程，那么在那里下载图像通常不是一个好主意。 Cache.java 检查 rowObject.mBitmapUrl 是否已在任务中，如果是，则不会启动另一个任务。 因此，我们很可能不会超出 AsyncTask 池的工作队列限制。

下载：

您可以从 https://www.dropbox.com/s/ 下载源代码pvr9zyl811tfeem/ListViewImageCache.zip。

---

最后的话：

我已经测试了几周了，还没有遇到任何 OOM 异常。 我已经在模拟器、Nexus One 和 Nexus S 上对此进行了测试。我已经测试了包含高清质量图像的图像 URL。 唯一的瓶颈是下载需要更多时间。

我可以想象只有一种可能的情况会出现 OOM，那就是如果我们下载许多非常大的图像，并且在它们被缩放并放入缓存之前，将同时占用更多内存并导致 OOM。 但无论如何，这都不是一个理想的情况，而且很可能无法以更可行的方式解决。

在评论中报告错误！ :-)

Answer 6

我执行了以下操作来拍摄图像并动态调整其大小。 希望这可以帮助

Bitmap bm;
bm = Bitmap.createScaledBitmap(BitmapFactory.decodeFile(filepath), 100, 100, true);
mPicture = new ImageView(context);
mPicture.setImageBitmap(bm);    

Answer 7

不幸的是如果以上都不起作用，请将其添加到您的Manifest文件中。 在 application 标签内

 <application
         android:largeHeap="true"

Answer 8

看来这是一个长期存在的问题，有很多不同的解释。 我采纳了这里两个最常见的答案的建议，但是这些都没有解决我的问题，即虚拟机声称它无法承担执行过程的解码部分的字节数。 经过一番挖掘，我了解到这里真正的问题是解码过程从 NATIVE 堆中获取信息。

请参阅此处： BitmapFactory OOM 让我发疯

这让我进行了另一场讨论我找到了这个问题的更多解决方案。 一种是在图像显示后手动调用System.gc();。 但这实际上会使您的应用程序使用更多内存，以减少本机堆。 从 2.0 (Donut) 版本开始，更好的解决方案是使用 BitmapFactory 选项“inPurgeable”。 因此，我只是在 o2.inSampleSize=scale; 之后添加了 o2.inPurgeable=true;。

有关该主题的更多信息，请参见：内存堆的限制只有 6M 吗？

说了这么多，我对 Java 和 Android 也是个十足的傻瓜。 因此，如果您认为这是解决该问题的糟糕方法，那么您可能是对的。 ;-) 但这对我来说创造了奇迹，我发现现在不可能从堆缓存中运行虚拟机。 我发现的唯一缺点是您正在丢弃缓存的绘制图像。 这意味着如果您直接返回该图像，您每次都会重新绘制它。 就我的应用程序的工作方式而言，这并不是真正的问题。 你的旅费可能会改变。

Answer 9

使用此 bitmap.recycle(); 这有助于避免任何图像质量问题。

Answer 10

我已通过以下方式解决了同样的问题。

Bitmap b = null;
Drawable d;
ImageView i = new ImageView(mContext);
try {
    b = Bitmap.createBitmap(320,424,Bitmap.Config.RGB_565);
    b.eraseColor(0xFFFFFFFF);
    Rect r = new Rect(0, 0,320 , 424);
    Canvas c = new Canvas(b);
    Paint p = new Paint();
    p.setColor(0xFFC0C0C0);
    c.drawRect(r, p);
    d = mContext.getResources().getDrawable(mImageIds[position]);
    d.setBounds(r);
    d.draw(c);

    /*   
        BitmapFactory.Options o2 = new BitmapFactory.Options();
        o2.inTempStorage = new byte[128*1024];
        b = BitmapFactory.decodeStream(mContext.getResources().openRawResource(mImageIds[position]), null, o2);
        o2.inSampleSize=16;
        o2.inPurgeable = true;
    */
} catch (Exception e) {

}
i.setImageBitmap(b);

Answer 11

我有一个更有效的解决方案，不需要任何形式的扩展。 只需对位图解码一次，然后根据其名称将其缓存在地图中。 然后只需根据名称检索位图并将其设置在 ImageView 中即可。 没有什么需要做的了。

这是可行的，因为解码位图的实际二进制数据不存储在 dalvik VM 堆中。 它存储在外部。 因此，每次解码位图时，它都会在 VM 堆之外分配内存，而这些内存永远不会被 GC 回收。

为了帮助您更好地理解这一点，假设您已将图像保存在可绘制文件夹中。 您只需通过执行 getResources().getDrwable(R.drawable.) 即可获取图像。 这不会每次都解码您的图像，而是在每次调用它时重新使用已经解码的实例。 所以本质上它是被缓存的。

现在，由于您的图像位于某个文件中（或者甚至可能来自外部服务器），因此您有责任缓存已解码的位图实例，以便在任何需要的地方重用。

希望这可以帮助。

Answer 12

这里有两个问题......

• 位图内存不在虚拟机堆中，而是在本机堆中 - 请参阅 BitmapFactory OOM 让我抓狂
• 本机堆的垃圾收集比 VM 堆更懒 - 因此每次执行时都需要非常积极地执行 bitmap.recycle 和 bitmap =null通过 Activity 的 onPause 或 onDestroy

Answer 13

这对我有用！

public Bitmap readAssetsBitmap(String filename) throws IOException {
    try {
        BitmapFactory.Options options = new BitmapFactory.Options(); 
        options.inPurgeable = true;
        Bitmap bitmap = BitmapFactory.decodeStream(assets.open(filename), null, options);
        if(bitmap == null) {
            throw new IOException("File cannot be opened: It's value is null");
        } else {
            return bitmap;
        }
    } catch (IOException e) {
        throw new IOException("File cannot be opened: " + e.getMessage());
    }
}

Answer 14

这里的答案很好，但我想要一个完全可用的类来解决这个问题..所以我做了一个。

这是我的 BitmapHelper 类，它是 OutOfMemoryError 证明:-)

import java.io.File;
import java.io.FileInputStream;

import android.graphics.Bitmap;
import android.graphics.Bitmap.Config;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;

public class BitmapHelper
{

    //decodes image and scales it to reduce memory consumption
    public static Bitmap decodeFile(File bitmapFile, int requiredWidth, int requiredHeight, boolean quickAndDirty)
    {
        try
        {
            //Decode image size
            BitmapFactory.Options bitmapSizeOptions = new BitmapFactory.Options();
            bitmapSizeOptions.inJustDecodeBounds = true;
            BitmapFactory.decodeStream(new FileInputStream(bitmapFile), null, bitmapSizeOptions);

            // load image using inSampleSize adapted to required image size
            BitmapFactory.Options bitmapDecodeOptions = new BitmapFactory.Options();
            bitmapDecodeOptions.inTempStorage = new byte[16 * 1024];
            bitmapDecodeOptions.inSampleSize = computeInSampleSize(bitmapSizeOptions, requiredWidth, requiredHeight, false);
            bitmapDecodeOptions.inPurgeable = true;
            bitmapDecodeOptions.inDither = !quickAndDirty;
            bitmapDecodeOptions.inPreferredConfig = quickAndDirty ? Bitmap.Config.RGB_565 : Bitmap.Config.ARGB_8888;

            Bitmap decodedBitmap = BitmapFactory.decodeStream(new FileInputStream(bitmapFile), null, bitmapDecodeOptions);

            // scale bitmap to mathc required size (and keep aspect ratio)

            float srcWidth = (float) bitmapDecodeOptions.outWidth;
            float srcHeight = (float) bitmapDecodeOptions.outHeight;

            float dstWidth = (float) requiredWidth;
            float dstHeight = (float) requiredHeight;

            float srcAspectRatio = srcWidth / srcHeight;
            float dstAspectRatio = dstWidth / dstHeight;

            // recycleDecodedBitmap is used to know if we must recycle intermediary 'decodedBitmap'
            // (DO NOT recycle it right away: wait for end of bitmap manipulation process to avoid
            // java.lang.RuntimeException: Canvas: trying to use a recycled bitmap android.graphics.Bitmap@416ee7d8
            // I do not excatly understand why, but this way it's OK

            boolean recycleDecodedBitmap = false;

            Bitmap scaledBitmap = decodedBitmap;
            if (srcAspectRatio < dstAspectRatio)
            {
                scaledBitmap = getScaledBitmap(decodedBitmap, (int) dstWidth, (int) (srcHeight * (dstWidth / srcWidth)));
                // will recycle recycleDecodedBitmap
                recycleDecodedBitmap = true;
            }
            else if (srcAspectRatio > dstAspectRatio)
            {
                scaledBitmap = getScaledBitmap(decodedBitmap, (int) (srcWidth * (dstHeight / srcHeight)), (int) dstHeight);
                recycleDecodedBitmap = true;
            }

            // crop image to match required image size

            int scaledBitmapWidth = scaledBitmap.getWidth();
            int scaledBitmapHeight = scaledBitmap.getHeight();

            Bitmap croppedBitmap = scaledBitmap;

            if (scaledBitmapWidth > requiredWidth)
            {
                int xOffset = (scaledBitmapWidth - requiredWidth) / 2;
                croppedBitmap = Bitmap.createBitmap(scaledBitmap, xOffset, 0, requiredWidth, requiredHeight);
                scaledBitmap.recycle();
            }
            else if (scaledBitmapHeight > requiredHeight)
            {
                int yOffset = (scaledBitmapHeight - requiredHeight) / 2;
                croppedBitmap = Bitmap.createBitmap(scaledBitmap, 0, yOffset, requiredWidth, requiredHeight);
                scaledBitmap.recycle();
            }

            if (recycleDecodedBitmap)
            {
                decodedBitmap.recycle();
            }
            decodedBitmap = null;

            scaledBitmap = null;
            return croppedBitmap;
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
        return null;
    }

    /**
     * compute powerOf2 or exact scale to be used as {@link BitmapFactory.Options#inSampleSize} value (for subSampling)
     * 
     * @param requiredWidth
     * @param requiredHeight
     * @param powerOf2
     *            weither we want a power of 2 sclae or not
     * @return
     */
    public static int computeInSampleSize(BitmapFactory.Options options, int dstWidth, int dstHeight, boolean powerOf2)
    {
        int inSampleSize = 1;

        // Raw height and width of image
        final int srcHeight = options.outHeight;
        final int srcWidth = options.outWidth;

        if (powerOf2)
        {
            //Find the correct scale value. It should be the power of 2.

            int tmpWidth = srcWidth, tmpHeight = srcHeight;
            while (true)
            {
                if (tmpWidth / 2 < dstWidth || tmpHeight / 2 < dstHeight)
                    break;
                tmpWidth /= 2;
                tmpHeight /= 2;
                inSampleSize *= 2;
            }
        }
        else
        {
            // Calculate ratios of height and width to requested height and width
            final int heightRatio = Math.round((float) srcHeight / (float) dstHeight);
            final int widthRatio = Math.round((float) srcWidth / (float) dstWidth);

            // Choose the smallest ratio as inSampleSize value, this will guarantee
            // a final image with both dimensions larger than or equal to the
            // requested height and width.
            inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;
        }

        return inSampleSize;
    }

    public static Bitmap drawableToBitmap(Drawable drawable)
    {
        if (drawable instanceof BitmapDrawable)
        {
            return ((BitmapDrawable) drawable).getBitmap();
        }

        Bitmap bitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight(), Config.ARGB_8888);
        Canvas canvas = new Canvas(bitmap);
        drawable.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
        drawable.draw(canvas);

        return bitmap;
    }

    public static Bitmap getScaledBitmap(Bitmap bitmap, int newWidth, int newHeight)
    {
        int width = bitmap.getWidth();
        int height = bitmap.getHeight();
        float scaleWidth = ((float) newWidth) / width;
        float scaleHeight = ((float) newHeight) / height;

        // CREATE A MATRIX FOR THE MANIPULATION
        Matrix matrix = new Matrix();
        // RESIZE THE BIT MAP
        matrix.postScale(scaleWidth, scaleHeight);

        // RECREATE THE NEW BITMAP
        Bitmap resizedBitmap = Bitmap.createBitmap(bitmap, 0, 0, width, height, matrix, false);
        return resizedBitmap;
    }

}

Answer 15

上面的答案都不适合我，但我确实想出了一个非常丑陋的解决方法来解决这个问题。 我将一个非常小的 1x1 像素图像作为资源添加到我的项目中，并在调用垃圾收集之前将其加载到我的 ImageView 中。 我认为可能是 ImageView 没有释放 Bitmap，所以 GC 从未拾取它。 它很丑陋，但现在似乎有效。

if (bitmap != null)
{
  bitmap.recycle();
  bitmap = null;
}
if (imageView != null)
{
  imageView.setImageResource(R.drawable.tiny); // This is my 1x1 png.
}
System.gc();

imageView.setImageBitmap(...); // Do whatever you need to do to load the image you want.

Answer 16

这对我有用。

Bitmap myBitmap;

BitmapFactory.Options options = new BitmapFactory.Options(); 
options.InPurgeable = true;
options.OutHeight = 50;
options.OutWidth = 50;
options.InSampleSize = 4;

File imgFile = new File(filepath);
myBitmap = BitmapFactory.DecodeFile(imgFile.AbsolutePath, options);

这是在 C# monodroid 上。
您可以轻松更改图像的路径。 这里重要的是要设置的选项。

Answer 17

这似乎是与社区分享我的用于加载和处理图像的实用程序类的合适地方，欢迎您使用它并自由修改它。

package com.emil;

import java.io.IOException;
import java.io.InputStream;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;

/**
 * A class to load and process images of various sizes from input streams and file paths.
 * 
 * @author Emil http://stackoverflow.com/users/220710/emil
 *
 */
public class ImageProcessing {

    public static Bitmap getBitmap(InputStream stream, int sampleSize, Bitmap.Config bitmapConfig) throws IOException{
        BitmapFactory.Options options=ImageProcessing.getOptionsForSampling(sampleSize, bitmapConfig);
        Bitmap bm = BitmapFactory.decodeStream(stream,null,options);
        if(ImageProcessing.checkDecode(options)){
            return bm;
        }else{
            throw new IOException("Image decoding failed, using stream.");
        }
    }

    public static Bitmap getBitmap(String imgPath, int sampleSize, Bitmap.Config bitmapConfig) throws IOException{
        BitmapFactory.Options options=ImageProcessing.getOptionsForSampling(sampleSize, bitmapConfig);
        Bitmap bm = BitmapFactory.decodeFile(imgPath,options);
        if(ImageProcessing.checkDecode(options)){
            return bm;
        }else{
            throw new IOException("Image decoding failed, using file path.");
        }
    }

    public static Dimensions getDimensions(InputStream stream) throws IOException{
        BitmapFactory.Options options=ImageProcessing.getOptionsForDimensions();
        BitmapFactory.decodeStream(stream,null,options);
        if(ImageProcessing.checkDecode(options)){
            return new ImageProcessing.Dimensions(options.outWidth,options.outHeight);
        }else{
            throw new IOException("Image decoding failed, using stream.");
        }
    }

    public static Dimensions getDimensions(String imgPath) throws IOException{
        BitmapFactory.Options options=ImageProcessing.getOptionsForDimensions();
        BitmapFactory.decodeFile(imgPath,options);
        if(ImageProcessing.checkDecode(options)){
            return new ImageProcessing.Dimensions(options.outWidth,options.outHeight);
        }else{
            throw new IOException("Image decoding failed, using file path.");
        }
    }

    private static boolean checkDecode(BitmapFactory.Options options){
        // Did decode work?
        if( options.outWidth<0 || options.outHeight<0 ){
            return false;
        }else{
            return true;
        }
    }

    /**
     * Creates a Bitmap that is of the minimum dimensions necessary
     * @param bm
     * @param min
     * @return
     */
    public static Bitmap createMinimalBitmap(Bitmap bm, ImageProcessing.Minimize min){
        int newWidth, newHeight;
        switch(min.type){
        case WIDTH:
            if(bm.getWidth()>min.minWidth){
                newWidth=min.minWidth;
                newHeight=ImageProcessing.getScaledHeight(newWidth, bm);
            }else{
                // No resize
                newWidth=bm.getWidth();
                newHeight=bm.getHeight();
            }
            break;
        case HEIGHT:
            if(bm.getHeight()>min.minHeight){
                newHeight=min.minHeight;
                newWidth=ImageProcessing.getScaledWidth(newHeight, bm);
            }else{
                // No resize
                newWidth=bm.getWidth();
                newHeight=bm.getHeight();
            }
            break;
        case BOTH: // minimize to the maximum dimension
        case MAX:
            if(bm.getHeight()>bm.getWidth()){
                // Height needs to minimized
                min.minDim=min.minDim!=null ? min.minDim : min.minHeight;
                if(bm.getHeight()>min.minDim){
                    newHeight=min.minDim;
                    newWidth=ImageProcessing.getScaledWidth(newHeight, bm);
                }else{
                    // No resize
                    newWidth=bm.getWidth();
                    newHeight=bm.getHeight();
                }
            }else{
                // Width needs to be minimized
                min.minDim=min.minDim!=null ? min.minDim : min.minWidth;
                if(bm.getWidth()>min.minDim){
                    newWidth=min.minDim;
                    newHeight=ImageProcessing.getScaledHeight(newWidth, bm);
                }else{
                    // No resize
                    newWidth=bm.getWidth();
                    newHeight=bm.getHeight();
                }
            }
            break;
        default:
            // No resize
            newWidth=bm.getWidth();
            newHeight=bm.getHeight();
        }
        return Bitmap.createScaledBitmap(bm, newWidth, newHeight, true);
    }

    public static int getScaledWidth(int height, Bitmap bm){
        return (int)(((double)bm.getWidth()/bm.getHeight())*height);
    }

    public static int getScaledHeight(int width, Bitmap bm){
        return (int)(((double)bm.getHeight()/bm.getWidth())*width);
    }

    /**
     * Get the proper sample size to meet minimization restraints
     * @param dim
     * @param min
     * @param multipleOf2 for fastest processing it is recommended that the sample size be a multiple of 2
     * @return
     */
    public static int getSampleSize(ImageProcessing.Dimensions dim, ImageProcessing.Minimize min, boolean multipleOf2){
        switch(min.type){
        case WIDTH:
            return ImageProcessing.getMaxSampleSize(dim.width, min.minWidth, multipleOf2);
        case HEIGHT:
            return ImageProcessing.getMaxSampleSize(dim.height, min.minHeight, multipleOf2);
        case BOTH:
            int widthMaxSampleSize=ImageProcessing.getMaxSampleSize(dim.width, min.minWidth, multipleOf2);
            int heightMaxSampleSize=ImageProcessing.getMaxSampleSize(dim.height, min.minHeight, multipleOf2);
            // Return the smaller of the two
            if(widthMaxSampleSize<heightMaxSampleSize){
                return widthMaxSampleSize;
            }else{
                return heightMaxSampleSize;
            }
        case MAX:
            // Find the larger dimension and go bases on that
            if(dim.width>dim.height){
                return ImageProcessing.getMaxSampleSize(dim.width, min.minDim, multipleOf2);
            }else{
                return ImageProcessing.getMaxSampleSize(dim.height, min.minDim, multipleOf2);
            }
        }
        return 1;
    }

    public static int getMaxSampleSize(int dim, int min, boolean multipleOf2){
        int add=multipleOf2 ? 2 : 1;
        int size=0;
        while(min<(dim/(size+add))){
            size+=add;
        }
        size = size==0 ? 1 : size;
        return size;        
    }

    public static class Dimensions {
        int width;
        int height;

        public Dimensions(int width, int height) {
            super();
            this.width = width;
            this.height = height;
        }

        @Override
        public String toString() {
            return width+" x "+height;
        }
    }

    public static class Minimize {
        public enum Type {
            WIDTH,HEIGHT,BOTH,MAX
        }
        Integer minWidth;
        Integer minHeight;
        Integer minDim;
        Type type;

        public Minimize(int min, Type type) {
            super();
            this.type = type;
            switch(type){
            case WIDTH:
                this.minWidth=min;
                break;
            case HEIGHT:
                this.minHeight=min;
                break;
            case BOTH:
                this.minWidth=min;
                this.minHeight=min;
                break;
            case MAX:
                this.minDim=min;
                break;
            }
        }

        public Minimize(int minWidth, int minHeight) {
            super();
            this.type=Type.BOTH;
            this.minWidth = minWidth;
            this.minHeight = minHeight;
        }

    }

    /**
     * Estimates size of Bitmap in bytes depending on dimensions and Bitmap.Config
     * @param width
     * @param height
     * @param config
     * @return
     */
    public static long estimateBitmapBytes(int width, int height, Bitmap.Config config){
        long pixels=width*height;
        switch(config){
        case ALPHA_8: // 1 byte per pixel
            return pixels;
        case ARGB_4444: // 2 bytes per pixel, but depreciated
            return pixels*2;
        case ARGB_8888: // 4 bytes per pixel
            return pixels*4;
        case RGB_565: // 2 bytes per pixel
            return pixels*2;
        default:
            return pixels;
        }
    }

    private static BitmapFactory.Options getOptionsForDimensions(){
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds=true;
        return options;
    }

    private static BitmapFactory.Options getOptionsForSampling(int sampleSize, Bitmap.Config bitmapConfig){
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = false;
        options.inDither = false;
        options.inSampleSize = sampleSize;
        options.inScaled = false;
        options.inPreferredConfig = bitmapConfig;
        return options;
    }
}

Answer 18

在我的一个应用程序中，我需要从相机/图库拍照。 如果用户点击相机中的图像（可能是 2MP、5MP 或 8MP），图像大小会从 kB 秒到 MB 秒变化。 如果图像大小小于（或最多 1-2MB），上述代码工作正常，但如果我的图像大小超过 4MB 或 5MB，则 OOM 出现在框架中:(

那么我已经努力解决这个问题最后我对 Fedor 的代码做了以下改进（感谢 Fedor 提出了这么好的解决方案）:)

private Bitmap decodeFile(String fPath) {
    // Decode image size
    BitmapFactory.Options opts = new BitmapFactory.Options();
    /*
     * 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.
     */
    opts.inJustDecodeBounds = true;
    opts.inDither = false; // Disable Dithering mode
    opts.inPurgeable = true; // Tell to gc that whether it needs free
                                // memory, the Bitmap can be cleared
    opts.inInputShareable = true; // Which kind of reference will be used to
                                    // recover the Bitmap data after being
                                    // clear, when it will be used in the
                                    // future

    BitmapFactory.decodeFile(fPath, opts);

    // The new size we want to scale to
    final int REQUIRED_SIZE = 70;

    // Find the correct scale value. 
    int scale = 1;

    if (opts.outHeight > REQUIRED_SIZE || opts.outWidth > REQUIRED_SIZE) {

        // Calculate ratios of height and width to requested height and width
        final int heightRatio = Math.round((float) opts.outHeight
                / (float) REQUIRED_SIZE);
        final int widthRatio = Math.round((float) opts.outWidth
                / (float) REQUIRED_SIZE);

        // Choose the smallest ratio as inSampleSize value, this will guarantee
        // a final image with both dimensions larger than or equal to the
        // requested height and width.
        scale = heightRatio < widthRatio ? heightRatio : widthRatio;//
    }

    // Decode bitmap with inSampleSize set
    opts.inJustDecodeBounds = false;

    opts.inSampleSize = scale;

    Bitmap bm = BitmapFactory.decodeFile(fPath, opts).copy(
            Bitmap.Config.RGB_565, false);

    return bm;

}

我希望这能帮助面临同样问题的朋友！

有关更多信息，请参阅此

Answer 19

几分钟前我刚刚遇到这个问题。 我通过更好地管理列表视图适配器解决了这个问题。 我认为这是我使用的数百个 50x50px 图像的问题，事实证明，每次显示行时我都试图夸大我的自定义视图。 只需测试该行是否已膨胀，我就消除了此错误，并且我使用了数百个位图。 这实际上是针对 Spinner 的，但基本适配器对于 ListView 的工作原理是一样的。 这个简单的修复也极大地提高了适配器的性能。

@Override
public View getView(final int position, View convertView, final ViewGroup parent) {

    if(convertView == null){
        LayoutInflater inflater = (LayoutInflater) mContext.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
        convertView = inflater.inflate(R.layout.spinner_row, null);
    }
...

Answer 20

此问题仅发生在 Android 模拟器中。 我在模拟器中也遇到了这个问题，但是当我签入设备时，它工作正常。

所以请检查设备。 它可以在设备中运行。

Answer 21

我花了一整天的时间测试这些解决方案，唯一对我有用的是上述获取图像和手动调用 GC 的方法，我知道这不是必需的，但这是唯一有效的方法当我将我的应用程序置于重负载测试活动之间切换时。 我的应用程序在列表视图中有一个缩略图列表（假设是活动 A），当您单击其中一个图像时，它会将您带到另一个活动（假设是活动 B），该活动显示该项目的主图像。 当我在两个活动之间来回切换时，我最终会收到 OOM 错误，并且应用程序将强制关闭。

当我到达列表视图的一半时，它就会崩溃。

现在，当我在活动 B 中实现以下操作时，我可以毫无问题地浏览整个列表视图，并继续前进……而且速度非常快。

@Override
public void onDestroy()
{   
    Cleanup();
    super.onDestroy();
}

private void Cleanup()
{    
    bitmap.recycle();
    System.gc();
    Runtime.getRuntime().gc();  
}

Answer 22

这里的所有解决方案都需要设置 IMAGE_MAX_SIZE。 这限制了具有更强大硬件的设备，如果图像尺寸太小，它在高清屏幕上看起来很难看。

我提出了一个适用于我的三星 Galaxy S3 和其他几种设备（包括功能较弱的设备）的解决方案，当使用功能更强大的设备时，图像质量会更好。

其要点是计算特定设备上为应用程序分配的最大内存，然后将比例设置为尽可能低而不超过此内存。 代码如下：

public static Bitmap decodeFile(File f)
{
    Bitmap b = null;
    try
    {
        // Decode image size
        BitmapFactory.Options o = new BitmapFactory.Options();
        o.inJustDecodeBounds = true;

        FileInputStream fis = new FileInputStream(f);
        try
        {
            BitmapFactory.decodeStream(fis, null, o);
        }
        finally
        {
            fis.close();
        }

        // In Samsung Galaxy S3, typically max memory is 64mb
        // Camera max resolution is 3264 x 2448, times 4 to get Bitmap memory of 30.5mb for one bitmap
        // If we use scale of 2, resolution will be halved, 1632 x 1224 and x 4 to get Bitmap memory of 7.62mb
        // We try use 25% memory which equals to 16mb maximum for one bitmap
        long maxMemory = Runtime.getRuntime().maxMemory();
        int maxMemoryForImage = (int) (maxMemory / 100 * 25);

        // Refer to
        // http://developer.android.com/training/displaying-bitmaps/cache-bitmap.html
        // A full screen GridView filled with images on a device with
        // 800x480 resolution would use around 1.5MB (800*480*4 bytes)
        // When bitmap option's inSampleSize doubled, pixel height and
        // weight both reduce in half
        int scale = 1;
        while ((o.outWidth / scale) * (o.outHeight / scale) * 4 > maxMemoryForImage)
        scale *= 2;

        // Decode with inSampleSize
        BitmapFactory.Options o2 = new BitmapFactory.Options();
        o2.inSampleSize = scale;
        fis = new FileInputStream(f);
        try
        {
            b = BitmapFactory.decodeStream(fis, null, o2);
        }
        finally
        {
            fis.close();
        }
    }
    catch (IOException e)
    {
    }
    return b;
}

我将此位图使用的最大内存设置为最大分配内存的 25%，您可能需要根据需要进行调整，并确保此位图已清理，并且在您使用后不会保留在内存中。使用完毕。 通常，我使用此代码来执行图像旋转（源位图和目标位图），因此我的应用程序需要同时在内存中加载 2 个位图，25% 为我提供了良好的缓冲区，在执行图像旋转时不会耗尽内存。

希望这可以帮助那里的人..

Answer 23

对从 SdCard 或可绘制对象中选择的每个图像使用这些代码来转换位图对象。

Resources res = getResources();
WindowManager window = (WindowManager) getSystemService(Context.WINDOW_SERVICE);
Display display = window.getDefaultDisplay();
@SuppressWarnings("deprecation")
int width = display.getWidth();
@SuppressWarnings("deprecation")
int height = display.getHeight();
try {
    if (bitmap != null) {
        bitmap.recycle();
        bitmap = null;
        System.gc();
    }
    bitmap = Bitmap.createScaledBitmap(BitmapFactory
        .decodeFile(ImageData_Path.get(img_pos).getPath()),
        width, height, true);
} catch (OutOfMemoryError e) {
    if (bitmap != null) {
        bitmap.recycle();
        bitmap = null;
        System.gc();
    }
    BitmapFactory.Options options = new BitmapFactory.Options();
    options.inPreferredConfig = Config.RGB_565;
    options.inSampleSize = 1;
    options.inPurgeable = true;
    bitmapBitmap.createScaledBitmap(BitmapFactory.decodeFile(ImageData_Path.get(img_pos)
        .getPath().toString(), options), width, height,true);
}
return bitmap;

使用您的图像路径代替 ImageData_Path.get(img_pos).getPath() 。

Answer 24

一般来说，如果您正在加载图像，Android 设备堆大小仅为 16MB（因​​设备/操作系统而异，请参阅帖子 堆大小）并且它的大小超过了16MB，它会抛出内存不足的异常，而不是使用Bitmap，从SD卡或从资源甚至从网络加载图像尝试使用 getImageUri ，加载位图需要更多内存，或者如果您使用该位图完成工作，则可以将位图设置为 null。

Answer 25

我的 2 美分：我通过以下方式解决了位图 OOM 错误：

a）将图像缩放 2 倍

b）使用 Picasso我的 ListView 的自定义适配器中的库，在 getView 中进行一次调用，如下所示：Picasso.with(context).load(R.id.myImage).into(R.id.myImageView);

Answer 26

此类OutofMemoryException无法通过调用System.gc()等方法完全解决。

参考活动生命周期< /strike>

活动状态由操作系统本身决定，具体取决于每个进程的内存使用情况和每个进程的优先级。

您可以考虑所使用的每个位图图片的大小和分辨率。 我建议缩小尺寸，重新采样到较低的分辨率，参考图库的设计（一张小图PNG，一张原图。）

Answer 27

此代码将有助于从可绘制对象加载大位图

public class BitmapUtilsTask extends AsyncTask<Object, Void, Bitmap> {

    Context context;

    public BitmapUtilsTask(Context context) {
        this.context = context;
    }

    /**
     * Loads a bitmap from the specified url.
     * 
     * @param url The location of the bitmap asset
     * @return The bitmap, or null if it could not be loaded
     * @throws IOException
     * @throws MalformedURLException
     */
    public Bitmap getBitmap() throws MalformedURLException, IOException {       

        // Get the source image's dimensions
        int desiredWidth = 1000;
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;

        BitmapFactory.decodeResource(context.getResources(), R.drawable.green_background , options);

        int srcWidth = options.outWidth;
        int srcHeight = options.outHeight;

        // Only scale if the source is big enough. This code is just trying
        // to fit a image into a certain width.
        if (desiredWidth > srcWidth)
            desiredWidth = srcWidth;

        // Calculate the correct inSampleSize/scale value. This helps reduce
        // memory use. It should be a power of 2
        int inSampleSize = 1;
        while (srcWidth / 2 > desiredWidth) {
            srcWidth /= 2;
            srcHeight /= 2;
            inSampleSize *= 2;
        }
        // Decode with inSampleSize
        options.inJustDecodeBounds = false;
        options.inDither = false;
        options.inSampleSize = inSampleSize;
        options.inScaled = false;
        options.inPreferredConfig = Bitmap.Config.ARGB_8888;
        options.inPurgeable = true;
        Bitmap sampledSrcBitmap;

        sampledSrcBitmap =  BitmapFactory.decodeResource(context.getResources(), R.drawable.green_background , options);

        return sampledSrcBitmap;
    }

    /**
     * The system calls this to perform work in a worker thread and delivers
     * it the parameters given to AsyncTask.execute()
     */
    @Override
    protected Bitmap doInBackground(Object... item) {
        try { 
          return getBitmap();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
}

Answer 28

要修复 OutOfMemory 错误，您应该执行以下操作：

BitmapFactory.Options options = new BitmapFactory.Options();
options.inSampleSize = 8;
Bitmap preview_bitmap = BitmapFactory.decodeStream(is, null, options);

此 inSampleSize 选项可减少内存消耗。

这是一个完整的方法。 首先，它读取图像大小而不解码内容本身。 然后它找到最佳的inSampleSize值，它应该是2的幂，最后对图像进行解码。

// Decodes image and scales it to reduce memory consumption
private Bitmap decodeFile(File f) {
    try {
        // Decode image size
        BitmapFactory.Options o = new BitmapFactory.Options();
        o.inJustDecodeBounds = true;
        BitmapFactory.decodeStream(new FileInputStream(f), null, o);

        // The new size we want to scale to
        final int REQUIRED_SIZE=70;

        // Find the correct scale value. It should be the power of 2.
        int scale = 1;
        while(o.outWidth / scale / 2 >= REQUIRED_SIZE && 
              o.outHeight / scale / 2 >= REQUIRED_SIZE) {
            scale *= 2;
        }

        // Decode with inSampleSize
        BitmapFactory.Options o2 = new BitmapFactory.Options();
        o2.inSampleSize = scale;
        return BitmapFactory.decodeStream(new FileInputStream(f), null, o2);
    } catch (FileNotFoundException e) {}
    return null;
}

Answer 29

Android 培训 课程，“高效显示位图"，提供了一些用于理解和处理异常“java.lang.OutOfMemoryError：位图大小超出 VM 预算”的重要信息加载位图时。

---

读取位图尺寸和类型

BitmapFactory 类提供了多种解码方法（decodeByteArray()、decodeFile()、decodeResource() 等）用于从各种来源创建位图。 根据您的图像数据源选择最合适的解码方法。 这些方法尝试为构造的位图分配内存，因此很容易导致 OutOfMemory 异常。 每种类型的解码方法都有附加签名，可让您通过 BitmapFactory.Options 类指定解码选项。 解码时将 inJustDecodeBounds 属性设置为 true 可以避免内存分配，为位图对象返回 null 但设置 outWidth， outHeight 和 outMimeType。 该技术允许您在构建位图（和内存分配）之前读取图像数据的尺寸和类型。

BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
BitmapFactory.decodeResource(getResources(), R.id.myimage, options);
int imageHeight = options.outHeight;
int imageWidth = options.outWidth;
String imageType = options.outMimeType;

为了避免 java.lang.OutOfMemory 异常，请在解码之前检查位图的尺寸，除非您绝对相信源会为您提供可预测大小的图像数据，并且适合可用内存。

---

将缩小版本加载到内存中

既然图像尺寸已知，它们可用于决定是否应将完整图像加载到内存中或是否应加载子采样版本。 以下是需要考虑的一些因素：

• 将完整图像加载到内存中的估计内存使用量。
• 考虑到应用程序的任何其他内存要求，您愿意承诺加载此图像的内存量。
• 图像要加载到的目标 ImageView 或 UI 组件的尺寸。
• 当前设备的屏幕尺寸和密度。

例如，如果最终将在 ImageView 中以 128x96 像素缩略图显示，则不值得将 1024x768 像素图像加载到内存中。

要告诉解码器对图像进行二次采样，将较小的版本加载到内存中，请在 BitmapFactory.Options 对象中将 inSampleSize 设置为 true。 例如，分辨率为 2048x1536 的图像使用 inSampleSize 4 进行解码会生成大约 512x384 的位图。 将其加载到内存中需要使用 0.75MB，而不是完整图像的 12MB（假设位图配置为 ARGB_8888）。 以下是根据目标宽度和高度计算样本大小值的方法，该值是 2 的幂：

public static int calculateInSampleSize(
        BitmapFactory.Options options, int reqWidth, int reqHeight) {
    // Raw height and width of image
    final int height = options.outHeight;
    final int width = options.outWidth;
    int inSampleSize = 1;

    if (height > reqHeight || width > reqWidth) {

        final int halfHeight = height / 2;
        final int halfWidth = width / 2;

        // Calculate the largest inSampleSize value that is a power of 2 and keeps both
        // height and width larger than the requested height and width.
        while ((halfHeight / inSampleSize) > reqHeight
                && (halfWidth / inSampleSize) > reqWidth) {
            inSampleSize *= 2;
        }
    }

    return inSampleSize;
}

注意：计算二值的幂是因为解码器使用
最终值向下舍入到最接近的 2 的幂，根据
inSampleSize 文档。

要使用此方法，首先将 inJustDecodeBounds 设置为 true 进行解码，传递选项，然后使用新的inSampleSize值和inJustDecodeBounds< 再次解码code>set tofalse`：

public static Bitmap decodeSampledBitmapFromResource(Resources res, int resId,
    int reqWidth, int reqHeight) {

    // First decode with inJustDecodeBounds=true to check dimensions
    final BitmapFactory.Options options = new BitmapFactory.Options();
    options.inJustDecodeBounds = true;
    BitmapFactory.decodeResource(res, resId, options);

    // Calculate inSampleSize
    options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);

    // Decode bitmap with inSampleSize set
    options.inJustDecodeBounds = false;
    return BitmapFactory.decodeResource(res, resId, options);
}

此方法可以轻松地将任意大尺寸的位图加载到显示 100x100 像素缩略图的 ImageView 中，如以下示例代码所示

mImageView.setImageBitmap(
    decodeSampledBitmapFromResource(getResources(), R.id.myimage, 100, 100));

：通过根据需要替换适当的 BitmapFactory.decode* 方法，可以遵循类似的过程来解码其他来源的位图。

Answer 30

我对 Fedor 的代码做了一个小小的改进。 它基本上做同样的事情，但是没有（在我看来）丑陋的 while 循环，它总是会产生 2 的幂。 感谢 Fedor 提出了最初的解决方案，我一直被困住，直到找到他的解决方案，然后我才能做出这个:)

 private Bitmap decodeFile(File f){
    Bitmap b = null;

        //Decode image size
    BitmapFactory.Options o = new BitmapFactory.Options();
    o.inJustDecodeBounds = true;

    FileInputStream fis = new FileInputStream(f);
    BitmapFactory.decodeStream(fis, null, o);
    fis.close();

    int scale = 1;
    if (o.outHeight > IMAGE_MAX_SIZE || o.outWidth > IMAGE_MAX_SIZE) {
        scale = (int)Math.pow(2, (int) Math.ceil(Math.log(IMAGE_MAX_SIZE / 
           (double) Math.max(o.outHeight, o.outWidth)) / Math.log(0.5)));
    }

    //Decode with inSampleSize
    BitmapFactory.Options o2 = new BitmapFactory.Options();
    o2.inSampleSize = scale;
    fis = new FileInputStream(f);
    b = BitmapFactory.decodeStream(fis, null, o2);
    fis.close();

    return b;
}