JVM 报 GC Overhead limit exceeded 是什么意思？

淩亂°似流年 2022-10-29 11:28 155阅读 0赞

默认情况下，并不是等堆内存耗尽，才会报 OutOfMemoryError，而是如果 JVM 觉得 GC 效率不高，也会报这个错误。

那么怎么评价 GC 效率不高呢？来看下源码：  
呢？来看下源码[gcOverheadChecker.cpp][]：

void GCOverheadChecker::check_gc_overhead_limit(GCOverheadTester* time_overhead,
                                                    GCOverheadTester* space_overhead,
                                                    bool is_full_gc,
                                                    GCCause::Cause gc_cause,
                                                    SoftRefPolicy* soft_ref_policy) {
    
      // 忽略显式gc命令，比如System.gc()，或者通过JVMTI命令的gc，或者通过jcmd命令的gc
      if (GCCause::is_user_requested_gc(gc_cause) ||
          GCCause::is_serviceability_requested_gc(gc_cause)) {
        return;
      }
    
      bool print_gc_overhead_limit_would_be_exceeded = false;
      if (is_full_gc) {
        //如果gc时间过长，并且gc回收的空间还是不多
        //gc时间占用98%以上为gc时间过长，可以通过 -XX:GCTimeLimit= 配置，参考gc_globals.hpp: GCTimeLimit
        //回收空间小于2%为gc回收空间不多，可以通过  -XX:GCHeapFreeLimit= 配置，参考gc_globals.hpp: GCHeapFreeLimit
        if (time_overhead->is_exceeded() && space_overhead->is_exceeded()) {
          _gc_overhead_limit_count++;
          //如果UseGCOverheadLimit这个状态位为开启
          //默认情况下，是开启的，可以通过启动参数-XX:-UseGCOverheadLimit关闭，参考：gc_globals.hpp: UseGCOverheadLimit
          if (UseGCOverheadLimit) {
            //如果超过规定次数，这个次数默认不可配置，必须开启develop编译jdk才能配置，参考gc_globals.hpp: GCOverheadLimitThreshold
            if (_gc_overhead_limit_count >= GCOverheadLimitThreshold){
              //设置状态位，准备抛出OOM
              set_gc_overhead_limit_exceeded(true);
              //清空计数
              reset_gc_overhead_limit_count();
            } else {
              //如果还没到达次数，但是也快到达的时候，清空所有的软引用
              bool near_limit = gc_overhead_limit_near();
              if (near_limit) {
                soft_ref_policy->set_should_clear_all_soft_refs(true);
                log_trace(gc, ergo)("Nearing GC overhead limit, will be clearing all SoftReference");
              }
            }
          }
          //需要打印日志，提示GC效率不高
          print_gc_overhead_limit_would_be_exceeded = true;
    
        } else {
          // Did not exceed overhead limits
          reset_gc_overhead_limit_count();
        }
      }
    
      if (UseGCOverheadLimit) {
        if (gc_overhead_limit_exceeded()) {
          log_trace(gc, ergo)("GC is exceeding overhead limit of " UINTX_FORMAT "%%", GCTimeLimit);
          reset_gc_overhead_limit_count();
        } else if (print_gc_overhead_limit_would_be_exceeded) {
          assert(_gc_overhead_limit_count > 0, "Should not be printing");
          log_trace(gc, ergo)("GC would exceed overhead limit of " UINTX_FORMAT "%% %d consecutive time(s)",
                              GCTimeLimit, _gc_overhead_limit_count);
        }
      }
    }

默认配置：gc\_globals.hpp

product(bool, UseGCOverheadLimit, true,                                   \
              "Use policy to limit of proportion of time spent in GC "          \
              "before an OutOfMemory error is thrown")                          \
                                                                                \
    product(uintx, GCTimeLimit, 98,                                           \
          "Limit of the proportion of time spent in GC before "             \
          "an OutOfMemoryError is thrown (used with GCHeapFreeLimit)")      \
          range(0, 100)                                                     \
                                                                            \
    product(uintx, GCHeapFreeLimit, 2,                                        \
          "Minimum percentage of free space after a full GC before an "     \
          "OutOfMemoryError is thrown (used with GCTimeLimit)")             \
          range(0, 100)                                                     \
                                                                            \
    develop(uintx, GCOverheadLimitThreshold, 5,                               \
          "Number of consecutive collections before gc time limit fires")   \
          range(1, max_uintx)

可以总结出：默认情况下，启用了 UseGCOverheadLimit，连续 5 次，碰到 GC 时间占比超过 98%，GC 回收的内存不足 2% 时，会抛出这个异常。

> **微信搜索“我的编程喵”关注公众号，每日一刷，轻松提升技术，斩获各种offer：**

> ![image][]

[gcOverheadChecker.cpp]: https://github.com/openjdk/jdk/blob/master/src/hotspot/share/gc/shared/gcOverheadChecker.cpp
[image]: /images/20221024/d2f623a8323e483c86ac790a87a91074.png