Android的oom详解

蔚落 2022-09-25 13:29 172阅读 0赞

# Android的oom原因 #

# 1.资源对象没关闭造成的内存泄露 #

try catch finally中将资源回收放到finally语句可以有效避免OOM。资源性对象比如：

1-1，Cursor  
1-2，调用registerReceiver后未调用unregisterReceiver()  
1-3，未关闭InputStream/OutputStream  
1-4，Bitmap使用后未调用recycle()

# 2.作用域不一样，导致对象的泄露 #

不能被垃圾回收器回收，比如：

2-1，非静态内部类会隐式地持有外部类的引用，  
2-2，Context泄露

# 3.内存压力过大 #

3-1，图片资源加载过多，超过内存使用空间，例如Bitmap 的使用  
3-2，重复创建view，listview应该使用convertview和viewholder

> ## 下面针对上面的几个原因说一下避免措施 ##
> 
> # 如何避免oom？ #
> 
> 一共三点：
> 
> # 1.避免对象的内存泄露 #
> 
> # 2.减小对象的内存占用 #
> 
> # 3.内存对象的重复利用 #

# 1.避免对象的内存泄露 #

内存对象的泄漏，会导致一些不再使用的对象无法及时释放，这样一方面占用了宝贵的内存空间，很容易导致后续需要分配内存的时候，空闲空间不足而出现OOM。显然，这还使得每级Generation的内存区域可用空间变小，gc就会更容易被触发，容易出现内存抖动，从而引起性能问题。

通常来说，Activity的泄漏是内存泄漏里面最严重的问题，它占用的内存多，影响面广，我们需要特别注意以下几种种情况导致的Activity泄漏，service内存泄露和其他内存泄露：

## 1） 内部类引用导致Activity的泄漏 ##

最典型的场景是Handler导致的Activity泄漏，如果Handler中有延迟的任务或者是等待执行的任务队列过长，都有可能因为Handler继续执行而导致Activity发生泄漏。此时的引用关系链是Looper -> MessageQueue -> Message -> Handler -> Activity。为了解决这个问题，可以在UI退出之前，执行remove Handler消息队列中的消息与runnable对象。或者是使用Static + WeakReference的方式来达到断开Handler与Activity之间存在引用关系的目的。

Activity Context被传递到其他实例中，这可能导致自身被引用而发生泄漏。  
内部类引起的泄漏不仅仅会发生在Activity上，其他任何内部类出现的地方，都需要特别留意！我们可以考虑尽量使用static类型的内部类，同时使用WeakReference的机制来避免因为互相引用而出现的泄露。

## 2）考虑使用Application Context而不是Activity Context ##

对于大部分非必须使用Activity Context的情况（Dialog的Context就必须是Activity Context），我们都可以考虑使用Application Context而不是Activity的Context，这样可以避免不经意的Activity泄露。、

## 3）Service引起的内存泄露 ##

典型的是Service忘记关闭，为了避免可以使用IntentService：会自动开一个线程，使用完关闭service

## 4）BroadCastReceiver引起的泄露 ##

## 概括一下，避免Context相关的内存泄露，记住以下事情： ##

比如onReceive方法里执行了太多的操作

## 5）注意临时Bitmap对象的及时回收 ##

虽然在大多数情况下，我们会对Bitmap增加缓存机制，但是在某些时候，部分Bitmap是需要及时回收的。例如临时创建的某个相对比较大的bitmap对象，在经过变换得到新的bitmap对象之后，应该尽快回收原始的bitmap，这样能够更快释放原始bitmap所占用的空间。

## 6）注意单例引起的内存泄露 ##

很多内存泄露是由于单例引起的，因为单例的声明周期是整个程序的声明周期。

## 7）线程引起的内存泄露 ##

Thread 引用其他对象也容易出现对象泄露。

# 2.减小对象的内存占用 #

避免OOM的第一步就是要尽量减少新分配出来的对象占用内存的大小，尽量使用更加轻量的对象。

## 1）使用更加轻量的数据结构 ##

使用ArrayMap和sparseMap代替hashmap。  
具体看我博客  
[ Android优化之ArrayMap][Android_ArrayMap]

## 2）避免在Android里面使用Enum ##

Android官方培训课程提到过“Enums often require more than twice as much memory as static constants. You should strictly avoid using enums on Android.”

## 3）减小Bitmap对象的内存占用。 ##

Bitmap是一个极容易消耗内存的大胖子，减小创建出来的Bitmap的内存占用是很重要的，通常来说有下面2个措施：

inSampleSize：缩放比例，在把图片载入内存之前，我们需要先计算出一个合适的缩放比例，避免不必要的大图载入。  
decode format：解码格式，选择ARGB\_8888/RBG\_565/ARGB\_4444/ALPHA\_8，存在很大差异。

### 代码分析 ###

我们在编写Android程序的时候经常要用到许多图片，不同图片总是会有不同的形状、不同的大小，但在大多数情况下，这些图片都会大于我们程序所需要的大小。比如说系统图片库里展示的图片大都是用手机摄像头拍出来的，这些图片的分辨率会比我们手机屏幕的分辨率高得多。大家应该知道，我们编写的应用程序都是有一定内存限制的，程序占用了过高的内存就容易出现OOM(OutOfMemory)异常。我们可以通过下面的代码看出每个应用程序最高可用内存是多少。

int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);  
    Log.d("TAG", "Max memory is " + maxMemory + "KB");

因此在展示高分辨率图片的时候，最好先将图片进行压缩。压缩后的图片大小应该和用来展示它的控件大小相近，在一个很小的ImageView上显示一张超大的图片不会带来任何视觉上的好处，但却会占用我们相当多宝贵的内存，而且在性能上还可能会带来负面影响。下面我们就来看一看，如何对一张大图片进行适当的压缩，让它能够以最佳大小显示的同时，还能防止OOM的出现。

## BitmapFactory类介绍 ##

BitmapFactory这个类提供了多个解析方法(decodeByteArray, decodeFile, decodeResource等)用于创建Bitmap对象，我们应该根据图片的来源选择合适的方法。比如SD卡中的图片可以使用decodeFile方法，网络上的图片可以使用decodeStream方法，资源文件中的图片可以使用decodeResource方法。这些方法会尝试为已经构建的bitmap分配内存，这时就会很容易导致OOM出现。为此每一种解析方法都提供了一个可选的BitmapFactory.Options参数，将这个参数的inJustDecodeBounds属性设置为true就可以让解析方法禁止为bitmap分配内存，返回值也不再是一个Bitmap对象，而是null。虽然Bitmap是null了，但是BitmapFactory.Options的outWidth、outHeight和outMimeType属性都会被赋值。这个技巧让我们可以在加载图片之前就获取到图片的长宽值和MIME类型，从而根据情况对图片进行压缩。如下代码所示：

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;

为了避免OOM异常，最好在解析每张图片的时候都先检查一下图片的大小，除非你非常信任图片的来源，保证这些图片都不会超出你程序的可用内存。  
现在图片的大小已经知道了，我们就可以决定是把整张图片加载到内存中还是加载一个压缩版的图片到内存中。

## 以下几个因素是我们需要考虑的： ##

预估一下加载整张图片所需占用的内存。  
用于展示这张图片的控件的实际大小。  
当前设备的屏幕尺寸和分辨率。

## 那我们怎样才能对图片进行压缩呢？ ##

通过设置BitmapFactory.Options中inSampleSize的值就可以实现。比如我们有一张2048*1536像素的图片，将inSampleSize的值设置为4，就可以把这张图片压缩成512*384像素。原本加载这张图片需要占用13M的内存，压缩后就只需要占用0.75M了(假设图片是ARGB\_8888类型，即每个像素点占用4个字节)。下面的方法可以根据传入的宽和高，计算出合适的inSampleSize值：

public static int calculateInSampleSize(BitmapFactory.Options options,  
            int reqWidth, int reqHeight) {  
        // 源图片的高度和宽度  
        final int height = options.outHeight;  
        final int width = options.outWidth;  
        int inSampleSize = 1;  
        if (height > reqHeight || width > reqWidth) {  
            // 计算出实际宽高和目标宽高的比率  
            final int heightRatio = Math.round((float) height / (float) reqHeight);  
            final int widthRatio = Math.round((float) width / (float) reqWidth);  
            // 选择宽和高中最小的比率作为inSampleSize的值，这样可以保证最终图片的宽和高  
            // 一定都会大于等于目标的宽和高。  
            inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;  
        }  
        return inSampleSize;  
    }

使用这个方法，首先你要将BitmapFactory.Options的inJustDecodeBounds属性设置为true，解析一次图片。然后将BitmapFactory.Options连同期望的宽度和高度一起传递到到calculateInSampleSize方法中，就可以得到合适的inSampleSize值了。之后再解析一次图片，使用新获取到的inSampleSize值，并把inJustDecodeBounds设置为false，就可以得到压缩后的图片了。

public static Bitmap decodeSampledBitmapFromResource(Resources res, int resId,  
            int reqWidth, int reqHeight) {  
        // 第一次解析将inJustDecodeBounds设置为true，来获取图片大小  
        final BitmapFactory.Options options = new BitmapFactory.Options();  
        options.inJustDecodeBounds = true;  
        BitmapFactory.decodeResource(res, resId, options);  
        // 调用上面定义的方法计算inSampleSize值  
        options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);  
        // 使用获取到的inSampleSize值再次解析图片  
        options.inJustDecodeBounds = false;  
        return BitmapFactory.decodeResource(res, resId, options);  
    }  
    下面的代码非常简单地将任意一张图片压缩成100*100的缩略图，并在ImageView上展示。
    [java] view plain copy
    mImageView.setImageBitmap(  
        decodeSampledBitmapFromResource(getResources(), R.id.myimage, 100, 100));

# 3.内存对象的重复利用 #

在Android上面最常用的一个缓存算法是LRU(Least Recently Use)  
这也是整个计算机缓存最常用的算法

## 1）复用系统自带的资源 ##

Android系统本身内置了很多的资源，例如字符串/颜色/图片/动画/样式以及简单布局等等，这些资源都可以在应用程序中直接引用。这样做不仅仅可以减少应用程序的自身负重，减小APK的大小，另外还可以一定程度上减少内存的开销，复用性更好。但是也有必要留意Android系统的版本差异性，对那些不同系统版本上表现存在很大差异，不符合需求的情况，还是需要应用程序自身内置进去。

## 2）列表控件的子View的复用 ##

注意在ListView/GridView等出现大量重复子组件的视图里面，通过Adapter对ConvertView的复用，以及ViewHolder提高捷信效率。

## 3）Bitmap对象的复用 ##

分别是inBitmap和图片缓存技术

在ListView与GridView等显示大量图片的控件里面需要使用LRU的机制来缓存处理好的Bitmap。

> *利用inBitmap的高级特性提高Android系统在Bitmap分配与释放执行效率上的提升(3.0以及4.4以后存在一些使用限制上的差异)。*

使用inBitmap属性可以告知Bitmap解码器去尝试使用已经存在的内存区域，新解码的bitmap会尝试去使用之前那张bitmap在heap中所占据的pixel data内存区域，而不是去问内存重新申请一块区域来存放bitmap。利用这种特性，即使是上千张的图片，也只会仅仅只需要占用屏幕所能够显示的图片数量的内存大小。

## 使用inBitmap需要注意几个限制条件： ##

在SDK 11 -> 18之间，重用的bitmap大小必须是一致的，例如给inBitmap赋值的图片大小为100-100，那么新申请的bitmap必须也为100-100才能够被重用。从SDK 19开始，新申请的bitmap大小必须小于或者等于已经赋值过的bitmap大小。  
新申请的bitmap与旧的bitmap必须有相同的解码格式，例如大家都是8888的，如果前面的bitmap是8888，那么就不能支持4444与565格式的bitmap了。 我们可以创建一个包含多种典型可重用bitmap的对象池，这样后续的bitmap创建都能够找到合适的“模板”去进行重用。如下图所示：

另外提一点：在2.x的系统上，尽管bitmap是分配在native层，但是还是无法避免被计算到OOM的引用计数器里面。这里提示一下，不少应用会通过反射BitmapFactory.Options里面的inNativeAlloc来达到扩大使用内存的目的，但是如果大家都这么做，对系统整体会造成一定的负面影响，建议谨慎采纳。

## 使用图片缓存技术 ##

### 背景 ###

在你应用程序的UI界面加载一张图片是一件很简单的事情，但是当你需要在界面上加载一大堆图片的时候，情况就变得复杂起来。在很多情况下，（比如使用ListView, GridView 或者 ViewPager 这样的组件），屏幕上显示的图片可以通过滑动屏幕等事件不断地增加，最终导致OOM。

为了保证内存的使用始终维持在一个合理的范围，通常会把被移除屏幕的图片进行回收处理。此时垃圾回收器也会认为你不再持有这些图片的引用，从而对这些图片进行GC操作。用这种思路来解决问题是非常好的，可是为了能让程序快速运行，在界面上迅速地加载图片，你又必须要考虑到某些图片被回收之后，用户又将它重新滑入屏幕这种情况。这时重新去加载一遍刚刚加载过的图片无疑是性能的瓶颈，你需要想办法去避免这个情况的发生。

这个时候，使用内存缓存技术可以很好的解决这个问题，它可以让组件快速地重新加载和处理图片。下面我们就来看一看如何使用内存缓存技术来对图片进行缓存，从而让你的应用程序在加载很多图片的时候可以提高响应速度和流畅性。

## 方法 ##

内存缓存技术对那些大量占用应用程序宝贵内存的图片提供了快速访问的方法。

## 其中最核心的类是LruCache ##

(此类在android-support-v4的包中提供) 。这个类非常适合用来缓存图片，它的主要算法原理是把最近使用的对象用强引用存储在 LinkedHashMap 中，并且把最近最少使用的对象在缓存值达到预设定值之前从内存中移除。

为了能够选择一个合适的缓存大小给LruCache, 有以下多个因素应该放入考虑范围内

你的设备可以为每个应用程序分配多大的内存？  
设备屏幕上一次最多能显示多少张图片？  
有多少图片需要进行预加载，因为有可能很快也会显示在屏幕上？  
你的设备的屏幕大小和分辨率分别是多少？  
一个超高分辨率的设备（例如 Galaxy Nexus) 比起一个较低分辨率的设备（例如 Nexus S），在持有相同数量图片的时候，需要更大的缓存空间。  
图片的尺寸和大小，还有每张图片会占据多少内存空间。  
图片被访问的频率有多高？会不会有一些图片的访问频率比其它图片要高？如果有的话，你也许应该让一些图片常驻在内存当中，或者使用多个LruCache 对象来区分不同组的图片。  
你能维持好数量和质量之间的平衡吗？有些时候，存储多个低像素的图片，而在后台去开线程加载高像素的图片会更加的有效。  
并没有一个指定的缓存大小可以满足所有的应用程序，这是由你决定的。

## 如何空间和速度 ##

根据不同的场景选择空间换速度（后果更容易OOM）还是速度换空间

下面是一个使用 LruCache 来缓存图片的例子：

private LruCache<String, Bitmap> mMemoryCache;  
      
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        // 获取到可用内存的最大值，使用内存超出这个值会引起OutOfMemory异常。  
        // LruCache通过构造函数传入缓存值，以KB为单位。  
        int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);  
        // 使用最大可用内存值的1/8作为缓存的大小。  
        int cacheSize = maxMemory / 8;  
        mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {  
            @Override  
            protected int sizeOf(String key, Bitmap bitmap) {  
                // 重写此方法来衡量每张图片的大小，默认返回图片数量。  
                return bitmap.getByteCount() / 1024;  
            }  
        };  
    }  
      
    public void addBitmapToMemoryCache(String key, Bitmap bitmap) {  
        if (getBitmapFromMemCache(key) == null) {  
            mMemoryCache.put(key, bitmap);  
        }  
    }  
      
    public Bitmap getBitmapFromMemCache(String key) {  
        return mMemoryCache.get(key);  
    }

在这个例子当中，使用了系统分配给应用程序的八分之一内存来作为缓存大小。在中高配置的手机当中，这大概会有4兆(32/8)的缓存空间。一个全屏幕的 GridView 使用4张 800x480分辨率的图片来填充，则大概会占用1.5兆的空间。因此，这个缓存大小可以存储2.5页的图片。

当向 ImageView 中加载一张图片时,首先会在 LruCache 的缓存中进行检查。如果找到了相应的键值，则会立刻更新ImageView ，否则开启一个后台线程来加载这张图片。

public void loadBitmap(int resId, ImageView imageView) {  
        final String imageKey = String.valueOf(resId);  
        final Bitmap bitmap = getBitmapFromMemCache(imageKey);  
        if (bitmap != null) {  
            imageView.setImageBitmap(bitmap);  
        } else {  
            imageView.setImageResource(R.drawable.image_placeholder);  
            BitmapWorkerTask task = new BitmapWorkerTask(imageView);  
            task.execute(resId);  
        }  
    }  
    BitmapWorkerTask 还要把新加载的图片的键值对放到缓存中。
    [java] view plain copy
    class BitmapWorkerTask extends AsyncTask<Integer, Void, Bitmap> {  
        // 在后台加载图片。  
        @Override  
        protected Bitmap doInBackground(Integer... params) {  
            final Bitmap bitmap = decodeSampledBitmapFromResource(  
                    getResources(), params[0], 100, 100);  
            addBitmapToMemoryCache(String.valueOf(params[0]), bitmap);  
            return bitmap;  
        }  
    }

### 另外一个核心的类是LruDiskCache ###

硬盘缓存，具体参考网络吧，不仔细讲了

## 4）避免在onDraw方法里面执行对象的创建 ##

类似onDraw等频繁调用的方法，一定需要注意避免在这里做创建对象的操作，因为他会迅速增加内存的使用，而且很容易引起频繁的gc，甚至是内存抖动。

## 5）StringBuilder和StringBuffer（线程安全） ##

在有些时候，代码中会需要使用到大量的字符串拼接的操作，这种时候有必要考虑使用StringBuilder来替代频繁的“+”，比StringBuffer更高效。  
线程安全要求时候使用StringBuffer。

参考：  
主要参考胡凯的一片博客：  
http://hukai.me/android-performance-oom/  
还有：  
http://blog.csdn.net/guolin\_blog/article/details/9316683  
http://blog.csdn.net/boyupeng/article/details/47726765

[Android_ArrayMap]: http://blog.csdn.net/lpjishu/article/details/52504283