Android OOM：内存管理分析和内存泄露原因总结

时间：2022-03-03 20:56:57

一、Android进程的内存管理分析

1. 进程的地址空间

在32位操作系统中，进程的地址空间为0到4GB,示意图如下：
Android OOM：内存管理分析和内存泄露原因总结
这里主要说明一下Stack和Heap：

  • Stack空间：（进栈和出栈）由操作系统控制，其中主要存储 函数地址、函数参数、局部变量 等等。
    所以Stack空间不需要很大，一般为几MB大小。
  • Heap空间：使用由程序员控制，程序员可以使用malloc、new、free、delete等函数调用来操作这片地址空间。
    Heap为程序完成各种复杂任务提供内存空间，所以空间比较大，一般为几百MB到几GB。
    正是因为Heap空间由程序员管理，所以容易出现使用不当导致严重问题。

2. 进程内存空间和RAM之间的关系

  • 进程的内存空间只是 虚拟内存，而程序的运行需要的是实实在在的内存，即 物理内存（RAM）。
    在必要时，操作系统会将程序运行中申请的内存（虚拟内存）映射到RAM，让进程能够使用物理内存。
  • 另外，RAM的一部分被操作系统留作他用，比如显存 等等，内存映射和显存等都是由操作系统控制，我们也不必过多地关注它，进程所操作的空间都是虚拟地址空间，无法直接操作RAM 。

3. Android中的进程

  1. native进程：采用C/C++实现，不包含dalvik实例的linux进程**，/system/bin/目录下面的程序文件运行后都是以native进程形式存在的。比如/system/bin/surfaceflinger、/system/bin/rild、procrank等就是native进程。

  2. java进程：实例化了dalvik虚拟机实例的linux进程，进程的入口main函数为java函数。 dalvik虚拟机实例的宿主进程是fork()系统调用创建的linux进程，所以每一个Android上的java进程实际上就是一个linux进程，只是进程中多了一个dalvik虚拟机实例。因此，java进程的内存分配比native进程复杂。Android系统中的应用程序基本都是java进程，如桌面、电话、联系人、状态栏等等。

4. Android中进程的堆内存

  • heap空间 完全由程序员控制，我们使用malloc、C++ new和java new所申请的空间都是heap空间， C/C++申请的内存空间在native heap中，而java申请的内存空间则在dalvik heap中。

5. Android的 java程序为什么容易出现OOM

  • 因为Android系统对dalvik的vm heapsize作了硬性限制，当java进程申请的java空间超过阈值时，就会抛出OOM异常（这个阈值可以是48M、24M、16M等，视机型而定），可以通过adb shell getprop | grep dalvik.vm.heapgrowthlimit 查看此值。

  • 也就是说，程序发生OMM并不表示RAM不足，而是因为程序申请的java heap对象超过了dalvik vm heapgrowthlimit。也就是说，在RAM充足的情况下，也可能发生OOM。

  • 这样设计的 目的是为了让Android系统能同时让比较多的进程常驻内存，这样程序启动时就不用每次都重新加载到内存，能够给用户更快的响应 。

6. Android如何应对RAM不足

java程序发生OMM并不是表示RAM不足，如果RAM真的不足，会发生什么呢？ 这时Android的 memory killer 会起作用，当RAM所剩不多时，memory killer会杀死一些优先级比较低的进程来释放物理内存，让高优先级程序得到更多的内存。我们在分析log时，看到的进程被杀的log。

  Process com.xxx.xxxx(pid xxxx) has died.

7. 应用程序如何绕过dalvikvm heapsize的限制

对于一些大型的应用程序（比如游戏），内存使用会比较多，很容易超超出vm heapsize的限制，这时怎么保证程序不会因为OOM而崩溃呢？

  1. 创建子进程

    • 创建一个新的进程，那么我们就可以把一些对象分配到新进程的heap上了，从而 达到一个应用程序使用更多的内存的目的，当然，创建子进程会增加系统开销，而且并不是所有应用程序都适合这样做，视需求而定。
    • 创建子进程的方法：使用android:process标签

  2. 使用jni在 native heap 上申请空间（推荐使用）

    • 因为 native heap 的增长并不受 dalvik vm heapsize 的限制。
    • 只要RAM有剩余空间，程序员可以一直在native heap上申请空间，当然如果 RAM快耗尽，memory killer 会杀进程释放 RAM。
    • 我们在使用一些软件时，有时候会闪退，就可能是软件在native层申请了比较多的内存导致的。比如 UC web 在浏览内容比较多的网页时可能闪退，原因就是其native heap增长到比较大的值，占用了大量的 RAM，被memory killer杀掉了。
  3. 使用显存（操作系统预留RAM的一部分作为显存）
    • 使用OpenGL textures等API，texture memory不受dalvik vm heapsize限制，这个没实践过。
    • 再比如Android中的GraphicBufferAllocator申请的内存就是显存。

8. java程序如何才能创建native对象

必须使用 jni，而且应该用C语言的malloc或者C++的new关键字。
实例代码如下：

    JNIEXPORT void JNICALLJava_com_example_demo_TestMemory_nativeMalloc(JNIEnv *, jobject)  
    {    
void *p= malloc(1024*1024*);
             SLOGD("allocate 50M Bytes memory");  
if (p !=NULL)  
             {         
//memorywill not used without calling memset() 
memset(p,0, 1024*1024*50);  
             }  else   SLOGE("mallocfailure.");  
       ...
       ...
free(p); // free memory 
    }

或者：

    JNIEXPORT voidJNICALL Java_com_example_demo_TestMemory_nativeMalloc(JNIEnv *, jobject)  
    {     
             SLOGD("allocate 50M Bytesmemory");  
char *p = new char[1024 * 1024 * 50];  
if (p != NULL)  
             {         
//memory will not usedwithout calling memset() 
memset(p, 1, 1024*1024*50);  
             } else  SLOGE("newobject failure.");  
      ...
      ...
free(p); //free memory 
    }

malloc或者new申请的内存是虚拟内存，申请之后不会立即映射到物理内存，即不会占用RAM。只有调用memset使用内存后，虚拟内存才会真正映射到RAM。

9. 明明还有很多内存，但是发生OOM了。。

  • 这种情况经常出现在生成Bitmap的时候。
  • 在一个函数里生成一个13m 的int数组，再该函数结束后，按理说这个int数组应该已经被释放了，或者说可以释放，这个13M的空间应该可以空出来。
  • 这个时候如果你继续生成一个10M的int数组是没有问题的，反而生成一个4M的Bitmap就会跳出OOM。这个就奇怪了，为什么10M的int够空间，反而4M的Bitmap不够呢？

在Android中：

  1. 一个进程的内存可以由2个部分组成：java 使用内存 ，C 使用内存
    这两个内存的和必须小于16M，不然就会出现大家熟悉的OOM，这个就是第一种OOM的情况。
  2. 一旦内存分配给Java后，以后这块内存即使释放后，也只能给Java的使用
    这个估计跟java虚拟机里把内存分成好几块进行缓存的原因有关，反正C就别想用到这块的内存了，所以如果Java突然占用了一个大块内存，即使很快释放了：
    • C 能使用的内存 = 16M - Java某一瞬间占用的最大内存
    • 而 Bitmap的生成是通过malloc进行内存分配的，占用的是C的内存，这个也就说明了，上述的4MBitmap无法生成的原因，因为在13M被Java用过后，剩下C能用的只有3M了。

二、了解dalvik的Garbage Collection

如图所示：
Android OOM：内存管理分析和内存泄露原因总结

  • GC会选择一些它了解 还存活的对象 作为 内存遍历的根节点（GC Roots），比方说thread stack中的变量，JNI中的全局变量，zygote中的对象（class loader加载）等，然后开始对heap进行遍历。到最后，部分没有直接或者间接引用到GC Roots的就是需要回收的垃圾，会被GC回收掉。
    如下图蓝色部分。
    Android OOM：内存管理分析和内存泄露原因总结

三、常见的内存泄漏

1. 非静态内部类 的静态实例 容易造成内存泄漏

    public class MainActivity extends Activity 
 {  
// 非静态内部类的静态实例
static Demo sInstance = null;  

@Override  
public void onCreate(BundlesavedInstanceState)  
        {  
super.onCreate(savedInstanceState);  
            setContentView(R.layout.activity_main);  
if (sInstance == null)  {  
               sInstance= new Demo();  
            }  
        }  

        class Demo  
        {  
void doSomething()  
            {  
                System.out.print("dosth.");  
            }  
        }  
    }
  • 上面的代码中的 sInstance 实例 类型为静态实例，在第一个MainActivity act1实例创建时，sInstance会获得并一直持有act1的引用。
  • 当MainAcitivity销毁后重建，因为sInstance持有act1的引用，所以act1是无法被GC回收的，进程中会存在2个MainActivity实例（act1和重建后的MainActivity实例），这个act1对象就是一个无用的但一直占用内存的对象，即无法回收的垃圾对象。
  • 所以，对于lauchMode不是singleInstance的Activity， 应该避免在activity里面实例化其非静态内部类的静态实例。

2. Activity使用静态成员

    private static Drawable sBackground;   

@Override    
protected void onCreate(Bundle state) {    
super.onCreate(state);    

        TextView label = new TextView(this);    
        label.setText("Leaks are bad");    

if (sBackground == null) {    
            sBackground = getDrawable(R.drawable.large_bitmap);    
        }    
        label.setBackgroundDrawable(sBackground);    

        setContentView(label);    
    }
  • 由于用 静态成员sBackground 缓存了drawable对象，所以activity加载速度会加快，但是这样做是错误的。因为在android 2.3系统上，它会导致activity销毁后无法被系统回收。

label .setBackgroundDrawable()调用会将label赋值给sBackground的成员变量 mCallback。
上面代码意味着：sBackground（GC Root）会持有TextView对象，而TextView持有Activity对象。所以导致Activity对象无法被系统回收。

下面看看android4.0为了避免上述问题所做的改进。

  • 先看看android 2.3的Drawable.Java对setCallback的实现：
    public final void setCallback(Callback cb){
        mCallback = cb;
    }

// 在android 2.3中要避免内存泄漏也是可以做到的,
// 在activity的onDestroy时调用
// sBackgroundDrawable.setCallback(null)。
  • 再看看android 4.0的Drawable.Java对setCallback的实现：
    public final void setCallback(Callback cb){
        mCallback = newWeakReference<Callback> (cb);
    }

以上2个例子的内存泄漏都是因为 Activity的 引用的生命周期 超越了Activity 对象的生命周期。也就是常说的 Context泄漏，因为activity就是context。

3. 避免context相关的内存泄漏，需要注意以下几点

  • 不要对activity的context长期引用
    ( 一个activity的引用的生存周期应该和activity的生命周期相同 )

  • 如果可以的话，尽量使用关于application的context来替代和activity相关的context

  • 如果一个acitivity的非静态内部类的生命周期不受控制，那么避免使用它；正确的方法是 使用一个静态的内部类，并且对它的外部类有一WeakReference，就像在ViewRootImpl中内部类W所做的那样。

4. 使用handler时的内存问题

1) 我们知道，Handler通过发送Message与主线程交互。

  • Message发出之后是存储在MessageQueue中的，有些Message也不是马上就被处理的。
  • 在Message中存在一个 target，是Handler的一个引用，如果Message在Queue中存在的时间越长，就会导致Handler无法被回收。
  • 如果Handler是非静态的，则会导致Activity或者Service不会被回收。 所以正确处理Handler等之类的内部类，应该将自己的Handler定义为静态内部类。

2) HandlerThread的使用也需要注意：

  • 当我们在activity里面创建了一个HandlerThread，代码如下：
    public classMainActivity extends Activity  
    {  
        @Override  
        public void onCreate(BundlesavedInstanceState)  
        {  
            super.onCreate(savedInstanceState);  
            setContentView(R.layout.activity_main);  
            Thread mThread = newHandlerThread("demo", Process.THREAD_PRIORITY_BACKGROUND);   
            mThread.start();  
            MyHandler mHandler = new MyHandler( mThread.getLooper( ) );  
...
... 
        }  

        @Override  
        public void onDestroy()  
        {  
            super.onDestroy(); 
            // mThread.getLooper().quit(); 
        }  
    }

  • 这个代码存在泄漏问题，因为 HandlerThread的run方法是一个死循环，它不会自己结束，线程的生命周期超过了activity生命周期，当横竖屏切换，HandlerThread线程的数量会随着activity重建次数的增加而增加。

  • 应该在onDestroy时将线程停止掉：mThread.getLooper().quit();

另外，对于不是HandlerThread的线程，也应该确保activity消耗后，线程已经终止，可以这样做：在onDestroy时调用 mThread.join();

join( ) 的作用是：“等待该线程终止”，这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是：在子线程调用了join()方法后面的代码，只有等到子线程结束了才能执行。

5. 注册某个对象后未反注册

比如 注册广播接收器、注册观察者 等等。

  • 假设我们希望在锁屏界面(LockScreen)中，监听系统中的电话服务以获取一些信息(如信号强度等)，则可以在LockScreen中定义一个PhoneStateListener的对象，同时将它 注册 到TelephonyManager服务中。对于LockScreen对象，当需要显示锁屏界面的时候就会创建一个LockScreen对象，而当锁屏界面消失的时候LockScreen对象就会被释放掉。

  • 但是如果 在释放LockScreen对象的时候忘记取消我们之前注册的PhoneStateListener对象，则会导致LockScreen无法被GC回收。如果不断的使锁屏界面显示和消失，则最终会由于大量的LockScreen对象没有办法被回收而引起OutOfMemory,使得system_process进程挂掉。

虽然有些系统程序，它本身好像是可以自动取消注册的(当然不及时)，但是我们还是 应该在我们的程序中明确的取消注册，程序结束时应该把所有的注册都取消掉。

6. 集合中对象没清理造成的内存泄露

我们通常把一些对象的引用加入到了集合中，当我们不需要该对象时，如果没有把它的引用从集合中清理掉，这样这个集合就会越来越大。如果这个集合是static的话，那情况就更严重了。

  • 比如某公司的ROM的锁屏曾经就存在内存泄漏问题：
  • 这个泄漏是因为LockScreen**每次显示时会注册几个callback**，它们保存在
    KeyguardUpdateMonitor的ArrayList<InfoCallback>、
    ArrayList<SimStateCallback>
    等ArrayList实例中。但是在LockScreen**解锁后，这些callback没有被remove掉**，导致ArrayList不断增大， callback对象不断增多。这些callback对象的size并不大，heap增长比较缓慢，需要长时间地使用手机才能出现OOM，由于锁屏是驻留在system_server进程里，所以导致结果是手机重启。

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

  • 资源性对象 比如(Cursor，File文件等) 往往都用了一些缓冲，我们在不使用的时候，应该及时关闭它们，以便它们的缓冲及时回收内存。它们的缓冲不仅存在于Java虚拟机内，还存在于Java虚拟机外。
  • 如果我们仅仅是把它的引用设置为null,而不关闭它们，往往会造成内存泄露。因为有些资源性对象，比如SQLiteCursor(在析构函数finalize(),如果我们没有关闭它，它自己会调close()关闭)，如果我们没有关闭它，系统在回收它时也会关闭它，但是这样的效率太低了。因此对于资源性对象在不使用的时候，应该立即调用它的close()函数，将其关闭掉，然后再置为null.
  • 在我们的程序退出时一定要确保我们的资源性对象已经关闭。

8. 一些不良代码成内存压力

有些代码并不造成内存泄露，但是它们或是 对不使用的内存没进行有效及时的释放，或是没有有效的利用已有的对象而是频繁的申请新内存，对内存的回收和分配造成很大影响的。

1) Bitmap使用不当
  • 及时的销毁
    在用完Bitmap时，要及时的bitmap.recycle( )掉。
    注意，recycle( )并不能确定立即就会将Bitmap释放掉，但是会给虚拟机一个暗示：“该图片可以释放了”。
  • 设置采样率
    有时候，我们要显示的区域很小，没有必要将整个图片都加载出来，而只需要记载一个缩小过的图片，这时候可以设置一定的采样率，那么就可以大大减小占用的内存。如下面的代码：
    private ImageView preview; 
    BitmapFactory.Options options = newBitmapFactory.Options(); 
    // 图片宽高都为原来的二分之一，即图片为原来的四分之一   
    options.inSampleSize = 2;

    Bitmap bitmap = BitmapFactory.decodeStream(cr.openInputStream(uri), 
          null, options); preview.setImageBitmap(bitmap);
  • 巧妙的运用软引用（SoftRefrence）
    有些时候，我们使用Bitmap后没有保留对它的引用，因此就无法调用Recycle函数。这时候巧妙的运用软引用，可以使Bitmap在内存快不足时得到有效的释放。如下：
    SoftReference<Bitmap>  bitmap_ref  = new SoftReference<Bitmap>(
             BitmapFactory.decodeStream(inputstream));   
    ... 
    ...
if (bitmap_ref .get() != null) { 
          bitmap_ref.get().recycle();  
    }
2) 构造Adapter时，没有使用缓存的 convertView

  • 初始时ListView会从BaseAdapter中根据当前的屏幕布局实例化一定数量的view对象，同时ListView会将这些view对象缓存起来。

  • 当向上滚动ListView时，原先位于最上面的list item的view对象会被回收，然后被用来构造新出现的最下面的list item。这个构造过程就是由getView()方法完成的，getView()的第二个形参 View convertView就是被缓存起来的list item的view对象 ( 初始化时缓存中没有 view 对象,则 convertView 是 null )。

由此可以看出，如果我们不去使用convertView，而是每次都在getView()中重新实例化一个View对象的话，即浪费时间，也造成内存垃圾，给垃圾回收增加压力，如果垃圾回收来不及的话，虚拟机将不得不给该应用进程分配更多的内存，造成不必要的内存开支。

3) 不要在经常调用的方法中创建对象，尤其是忌讳在循环中创建对象。

可以适当的使用 hashtable ， vector 创建一组对象容器，然后从容器中去取那些对象，而不用每次 new 之后又丢弃。

9. 查询数据库而没有关闭Cursor

在Android中，Cursor是很常用的一个对象，但在写代码时，经常会有人忘记调用close, 或者因为代码逻辑问题状况导致close未被调用。

  • 通常，在Activity中，我们可以调用startManagingCursor或直接使用managedQuery让Activity自动管理Cursor对象。
    但需要注意的是，当Activity结束后，Cursor将不再可用！
  • 若操作Cursor的代码和UI不同步（如后台线程），需要先判断Activity是否已经结束，或者在调用OnDestroy前，先等待后台线程结束。
  • 除此之外，以下也是比较常见的Cursor不会被关闭的情况：
try {  
    Cursor c = queryCursor();  
    int a = c.getInt(1);  
    ......  
    c.close();  
} catch (Exception e) {  
} 
// 虽然表面看起来，Cursor.close()已经被调用
// 但若出现异常，将会跳过close()，从而导致内存泄露。
// 所以，我们的代码应该以如下的方式编写：

Cursor c = queryCursor();  
try {      
    int a = c.getInt(1);  
    ......  
} catch (Exception e) {  
} finally {  
    c.close(); // 在finally中调用close(), 保证其一定会被调用 
}

10. 调用registerReceiver后未调用unregisterReceiver()

在调用registerReceiver后，若未调用unregisterReceiver，其所占的内存是相当大的。
而我们经常可以看到类似于如下的代码：

registerReceiver(new BroadcastReceiver() {  
    ...  
}, filter); ...

这是个很严重的错误，因为它会导致BroadcastReceiver不会被unregister而导致内存泄露。

11. WebView对象没有销毁

当我们不要使用WebView对象时，应该调用它的destory()函数来销毁它，并释放其占用的内存，否则其占用的内存长期也不能被回收，从而造成内存泄露。

12. GridView的滥用

GridView和ListView的实现方式不太一样。GridView的View不是即时创建的，而是全部保存在内存中的。比如一个GridView有100项，虽然我们只能看到10项，但是其实整个100项都是在内存中的。

参考文章：
Android进程的内存管理分析
Android内存泄漏分析及调试

标签：

相关文章