OOM的起点到终点

前言

1.问题及现象

线上日志反馈内存溢出问题。根据用户反馈，客户操作一段时间之后，APP 内存溢出崩溃。

2.分析过程

(1) 分析线上日志，发现主要分两种：

第一种如下，可能是某个死循环导致内存不停增大导致:

java.lang.OutOfMemoryError: OutOfMemoryError thrown while trying to throw OutOfMemoryError; no stack trace available

第二种如下，压死骆驼的最后一根稻草：

java.lang.OutOfMemoryError: Failed to allocate a 16 byte allocation with 0 free bytes and 3GB until OOM, max allowed footprint 536872136, growth limit 536870912

这两种情况下都无法定位问题所在。

通过观察发生的版本信息，是从V9.5.6开始的，于是就开始查那期改动的功能（主要是webview优化，其他的是SDK更新），由于没有线上出问题的机型，就找个类似的华为机器操作webview，发现内存增长并不快，操作很长时间内存变化不大。

(2) 分析用户操作路径

让工程导出出现OOM问题用户最近的操作记录，埋点，页面停留，崩溃日志，观察进入了哪些页面，但是照着操作路径操作，也没发现崩溃。

(3) 统计出现问题的机型，前五都是华为的，系统版本7.0以上，内存3GB以上。

(4) 使用LeakCanary + Android Profiler排查泄漏的地方，查看线上日志的时候，偶然发现测试有一部手机出现了问题，华为P8，然后使用工具根据用户操作路径查各个模块泄漏问题，发现委托登录有个持续的10M泄漏，比较大的泄漏还有开屏广告页和行情登录页面34M。这个手机给APP分配的可用内存最大为256M，操作几次登录页面就崩溃了。

开屏页：

private ScheduledFuture<?> mTaskFuture = null;
private void gotoMain() {
    ...
    AdCountDownTask adCountDownTask = new AdCountDownTask();
    HexinThreadPool.cancelTaskFutre(mTaskFuture, true);
    mTaskFuture = HexinThreadPool.getThreadPool().sheduleWithFixedDelay(xxx);
    handler.sendEmptyMessageDelayed(xxx, xxx);
}
protected void onDestory() {
    ...
    if (mTaskFuture != null) {
        HexinThreadPool.cancelTaskFutre(mTaskFuture, true);
        mTaskFuture = null;
    }
}
复制代码

委托登录

public class AdsCT {
    private Runnable runable = new Runnable {
        // 轮播图片
        handler.postDelay(runnable, time);
    }
    public void onRemove() {
        handler.removeCallbacksAndMessages(null);
    }
}
public class WeituoLogin {
    public void onRemove() {
        adsCt.onRemove();
    }
}
复制代码

(5) 修改查出来比较大的内存泄漏，券商给之前出问题的两个用户单独安装，发现还是存在，券商反馈有个用户安装9.4.5的一直都没问题，升级到最新之后就出现问题了，现在怀疑还是9.4.6哪个模块导致的。

一：OOM是什么？

全称“Out Of Memory”，翻译成中文就是“内存用完了”，来源于java.lang.OutOfMemoryError。

二：OOM是哪里报错的？

Java内存模型

JVM内存结构主要有三大块：堆内存、方法区和栈。堆内存是JVM中最大的一块由年轻代和老年代组成，而年轻代内存又被分成三部分，Eden空间、From Survivor空间、To Survivor空间,默认情况下年轻代按照8:1:1的比例来分配；

方法区存储类信息、常量、静态变量等数据，是线程共享的区域，为与Java堆区分，方法区还有一个别名Non-Heap(非堆)；栈又分为java虚拟机栈和本地方法栈主要用于方法的执行。

三：为什么会发生OOM？

概念

内存泄露：申请使用完的内存没有释放，导致虚拟机不能再次使用该内存，此时这段内存就泄露了，因为申请者不用了，而又不能被虚拟机分配给别人用。

内存溢出：申请的内存超出了JVM能提供的内存大小，此时称之为溢出。

GC机制

可达性分析（Reachability Analysis）：从GC Roots开始向下搜索，搜索所走过的路径称为引用链。当一个对象到GC Roots没有任何引用链相连时，则证明此对象是不可用的。不可达对象。

申请一块内存时，如果当前可用内存不足，则会出发一次GC，然后再次申请，此时如果内存还不足，则会抛出OOM。

四：OOM常见实例和解决方案

1.内部类持有外部引用-Handler，Context

    // 错误示例，内部类持有外部对象导致泄漏
    private class MyHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
        }
    }
    // 修改后,在activity onDestory()的时候，调用myHandler.removeCallbacksAndMessages(null);
    private static class MyHandler extends Handler {
        private WeakReference<MainActivity> mainActivityWeakReference;
        public MyHandler(MainActivity mainActivity) {
            mainActivityWeakReference = new WeakReference<MainActivity>(mainActivity);
        }
        @Override
        public void handleMessage(Message msg) {
            MainActivity mainActivity = mainActivityWeakReference.get();
            if (mainActivity == null) {
                return;
            }
            mainActivity.jump(null);
            super.handleMessage(msg);
        }
    }
    // context被线程持有
    private void registerException(final Context context) {
        Thread.UncaughtExceptionHandler uncaughtExceptionHandler = new Thread.UncaughtExceptionHandler() {
            @Override
            public void uncaughtException(Thread t, Throwable e) {
                String appName = context.getResources().getString(R.string.app_name);
            }
        };
    }
复制代码

jvm四种引用

strong soft weak phantom(其实还有一种FinalReference，这个由jvm自己使用，外部无法调用到），主要的区别体现在gc上的处理，如下：

Strong类型，也就是正常使用的类型，不需要显示定义，只要没有任何引用就可以回收

SoftReference类型，如果一个对象只剩下一个soft引用，在jvm内存不足的时候会将这个对象进行回收

WeakReference类型，如果对象只剩下一个weak引用，那gc的时候就会回收。和SoftReference都可以用来实现cache

PhantomReference类型，

2.资源没有关闭-数据库，流

    private void testStream() {
        InputStream in = null;
        try {
            in = new FileInputStream("xxx.xml");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                in = null;
            }
        }
    }
复制代码

3.静态变量持有对象

单例持有Context，监听器等

五：OOM检查工具-LeakCanary原理

1.监听对象

Activity的监听，是在Activity onDestory()执行之后再看是否被回收，在Application创建的时候，注册了监听

Application.ActivityLifecycleCallbacks lifecycleCallbacks = new..{
    ...
    @Override public void onActivityDestroyed(Activity activity) {
          ActivityRefWatcher.this.onActivityDestroyed(activity);
        }
}
复制代码

工程中查看Page是否被释放，可以在onRemove()的时候使用

RefWatcher watch(Object obj)
复制代码

2.如何判断对象是否被释放？

使用的WeakReference+ReferenceQueue实现

final KeyedWeakReference reference =
        new KeyedWeakReference(watchedReference, key, referenceName, queue);
复制代码

如果软引用或弱引用所引用的对象被垃圾回收器回收，Java虚拟机就会把这个软引用或弱引用加入到与之关联的引用队列中，由此可判断对象是否被回收。

3.怎么让系统回收对象？

    @Override public void runGc() {
      Runtime.getRuntime().gc();
      enqueueReferences();
      System.runFinalization(); //强制调用已经失去引用的对象的finalize方法,确保释放实例占用的全部资源。
    }
    private void enqueueReferences() {
      try {
        Thread.sleep(100);
      } catch (InterruptedException e) {
        throw new AssertionError();
      }
    }
  };
复制代码

4.如何分析对象泄漏？

(1) 对内存文件进行分析，由于这个过程比较耗时，因此最终会把这个工作交给运行在另外一个进程中的HeapAnalyzerService来执行。

(2) 利用HAHA将之前dump出来的内存文件解析成Snapshot对象，解析得到的Snapshot对象直观上和我们使用MAT进行内存分析时候罗列出内存中各个对象的结构很相似，它通过对象之间的引用链关系构成了一棵树，我们可以在这个树种查询到各个对象的信息，包括它的Class对象信息、内存地址、持有的引用及被持有的引用关系等。

(3) 为了能够准确找到被泄漏对象，LeakCanary通过被泄漏对象的弱引用来在Snapshot中定位它。因为，如果一个对象被泄漏，一定也可以在内存中找到这个对象的弱引用，再通过弱引用对象的reference就可以直接定位被泄漏对象。

(4) 在Snapshot中找到一条有效的到被泄漏对象之间的引用路径，从被泄露的对象开始，采用的方法是类似于广度优先的搜索策略，将持有它引用的节点（父节点），加入到一个FIFO队列中，一层一层向上寻找，哪条路径最先到达GCRoot就表示它应该是一条最短路径。

(5) 将之前查找的最短路径转换成最后需要显示的LeakTrace对象，这个对象中包括了一个由路径上各个节点LeakTraceElement组成的链表，代表了检查到的最短泄漏路径。最后一个步骤就是将这些结果封装成AnalysisResult对象然后交给DisplayLeakService进行处理。这个service主要的工作是将检查结果写入文件，以便之后能够直接看到最近几次内存泄露的分析结果，同时以notification的方式通知用户检测到了一次内存泄漏。使用者还可以继承这个service类来并实现afterDefaultHandling来自定义对检查结果的处理，比如将结果上传刚到服务器等。

六：问题

1.OOM可以被捕获吗？

某些情况下是可以的，比如说局部申请一个很大的内存，如果造成了OOM，在catch的地方释放掉，程序还是可以继续往下执行的，但是如果捕获之后释放不掉，也还是会崩溃。

2.内部类为什么能访问外部类成员？

编译器会默认为成员内部类添加了一个指向外部类对象的引用，那么这个引用是如何赋初值的呢？

public com.xxx.Outter$Inner(com.cxh.test2.Outter);
复制代码

我们在定义的内部类的构造器是无参构造器，编译器还是会默认添加一个参数，该参数的类型为指向外部类对象的一个引用，所以成员内部类中的Outter this&0 指针便指向了外部类对象，因此可以在成员内部类中随意访问外部类的成员。从这里也间接说明了成员内部类是依赖于外部类的，如果没有创建外部类的对象，则无法对Outter this&0引用进行初始化赋值，也就无法创建成员内部类的对象了。

3.为什么局部内部类和匿名内部类只能访问局部final变量？

外部类和内部类编译后会生成两个.class文件，如果局部变量的值在编译期间就可以确定，则直接在匿名内部里面创建一个拷贝。如果局部变量的值无法在编译期间确定，则通过构造器传参的方式来对拷贝进行初始化赋值。
拷贝的话，如果一个值改变了，就会造成数据不一致性，为了解决这个问题，java编译器就限定必须将变量a限制为final变量，不允许对变量a进行更改（对于引用类型的变量，是不允许指向新的对象），这样数据不一致性的问题就得以解决了。

4.静态变量会被回收吗？finalize用法？

    private static StaticObj staticObj = new StaticObj();
    static class StaticObj {
        @Override
        protected void finalize() throws Throwable {
            staticObj = new StaticObj();
            super.finalize();
        }
    }
复制代码

5.System.gc()和Runtime.getRuntime().gc()区别？

    // System.gc()
    /**
     * If we just ran finalization, we might want to do a GC to free the finalized objects.
     * This lets us do gc/runFinlization/gc sequences but prevents back to back System.gc().
     */
    private static boolean justRanFinalization;
    public static void gc() {
        boolean shouldRunGC;
        synchronized (LOCK) {
            shouldRunGC = justRanFinalization;
            if (shouldRunGC) {
                justRanFinalization = false;
            } else {
                runGC = true;
            }
        }
        if (shouldRunGC) {
            Runtime.getRuntime().gc();
        }
    }
    public static void runFinalization() {
        boolean shouldRunGC;
        synchronized (LOCK) {
            shouldRunGC = runGC;
            runGC = false;
        }
        if (shouldRunGC) {
            Runtime.getRuntime().gc();
        }
        Runtime.getRuntime().runFinalization();
        synchronized (LOCK) {
            justRanFinalization = true;
        }
    }
复制代码

---

参考：

Jvm 系列(二):Jvm 内存结构

理解StrongReference,SoftReference, WeakReference的区别

Java内部类详解

性能优化工具（九）-LeakCanary

LeakCanary原理分析

转载于:https://juejin.im/post/5c87a88af265da2da53f0870