这似乎是一个长期存在的问题，有很多不同的解释。我采纳了这里给出的两个最常见答案的建议，但它们都没有解决我的VM声称它无法负担字节来执行过程的解码部分的问题。经过一番深入研究，我了解到这里的真正问题是解码过程从NATIVE堆中取出。

BitmapFactory OOM把我逼疯了

这将我引向另一个讨论线程，在那里我找到了这个问题的更多解决方案。一个是调用system .gc();显示图像后手动操作。但这实际上会使你的应用程序使用更多的内存，以减少本机堆。对于2.0版本(Donut)来说，更好的解决方案是使用BitmapFactory选项“inPurgeable”。所以我添加了o2.inPurgeable=true;就在o2.inSampleSize=scale;之后。

关于这个主题的更多信息:内存堆的限制只有6M吗?

现在，说了这么多，我对Java和Android也是个十足的笨蛋。所以如果你认为这是一个糟糕的解决问题的方法，你可能是对的。;-)但这已经为我工作的奇迹，我发现它不可能运行VM的堆缓存现在。唯一的缺点我能找到的是，你是垃圾缓存绘制的图像。这意味着如果你直接回到那个图像，你每次都要重新绘制它。就我的应用程序的工作方式而言，这并不是真正的问题。你的里程可能会有所不同。

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

我做了一个应用程序，故意引起OutOfMemoryError，并监控内存使用情况。

在对这个App做了大量的实验之后，我得到了以下结论:

在Honey Comb之前，我先谈谈SDK版本。

位图存储在原生堆中，但它会自动被垃圾收集，调用recycle()是不必要的。 如果{VM堆大小}+{已分配的本机堆内存}>={设备的VM堆大小限制}，并且您正在尝试创建位图，则会抛出OOM。 注意:计算的是虚拟机堆大小，而不是虚拟机已分配内存。 VM堆大小在增长后永远不会缩小，即使分配的VM内存减少了。 所以你必须保持VM内存的峰值尽可能低，以保持VM堆大小不会变得太大，以节省可用的内存位图。 手动调用system .gc()是没有意义的，系统会在尝试增加堆大小之前先调用它。 原生堆大小也永远不会缩小，但它不计入OOM，所以不用担心。

然后，让我们谈谈SDK从蜂巢开始。

位图存储在VM堆中，OOM不计算本机内存。 OOM的条件要简单得多:{虚拟机堆大小}>={设备的虚拟机堆大小限制}。 所以你有更多的可用内存来创建位图与相同的堆大小限制，OOM不太可能被抛出。

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

你可以自己在App中看到它。如果一个Activity执行了一个AsyncTask，而这个AsyncTask在Activity被销毁后仍然在运行，那么这个Activity在AsyncTask完成之前不会被垃圾收集。

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

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

回调也是匿名的内部类，所以如果项目中的静态实例持有它们并且不释放它们，内存就会泄漏。

如果你计划一个重复或延迟的任务，例如定时器，你不调用取消()和清除()在onPause()，内存将被泄漏。

使用这些代码为每一个图像在选择从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()的图像路径instend。

我花了一整天的时间来测试这些解决方案，唯一对我有用的是上面的获取图像和手动调用GC的方法，我知道这是不必要的，但当我把应用程序置于繁重的负载测试下时，这是唯一有效的方法。我的应用程序有一个缩略图列表在列表视图(让说活动a)，当你点击其中一个图像，它带你到另一个活动(让说活动B)，显示该项目的主图像。当我在两个活动之间来回切换时，我最终会得到OOM错误，应用程序将强制关闭。

当我走到列表视图一半的时候它就崩溃了。

现在，当我在活动B中实现以下内容时，我可以毫无问题地遍历整个列表视图，并继续下去……而且速度很快。

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

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

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

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;
    }
}

在浏览了所有的答案后，我惊讶地发现没有人提到用于处理图像的Glide API。伟大的库，并抽象出所有复杂的位图管理。使用这个库和一行代码就可以快速加载和调整图像大小。

     Glide.with(this).load(yourImageResource).into(imageview);

您可以在这里获得存储库:https://github.com/bumptech/glide