注意！！！HotswapAgent引發了OOM

作者：看山灬 2025-01-28 00:00:00

HotswapAgent在Spring啟動時改寫了CglibAopProxy的createEnhancer()方法，使用Cglib生成代理類時，不會使用緩存class，會重新生成class。在高并發場景中，請求中如果需要生成代理類，會重復生成class，造成Metaspace溢出，出現OOM。

這幾天在壓測服務，結果出現了Metaspace溢出，服務OOM了。本文從問題開始找到查找問題，到解決問題。

問題現象

服務在壓測過程中，出現了Metaspace空間不足，服務OOM的情況，經過在線分析，發現是一段創建任務的邏輯，在運行過程中創建并加載了很多相同的淚。

其中一個線程棧如下：

dynamic-kafka-worker-pool-sync_staging-async_topic-async_topic_c-3" Id=575 BLOCKED on org.springframework.boot.loader.LaunchedURLClassLoader@43e9089 owned by "dynamic-kafka-worker-pool-sync_staging-async_topic-async_topic_c-1" Id=572
    at org.springframework.cglib.core.AbstractClassGenerator.generate(AbstractClassGenerator.java:344)
    -  blocked on org.springframework.boot.loader.LaunchedURLClassLoader@43e9089
    at org.springframework.cglib.proxy.Enhancer.generate(Enhancer.java:582)
    at org.springframework.cglib.core.AbstractClassGenerator$ClassLoaderData.get(AbstractClassGenerator.java:131)
    at org.springframework.cglib.core.AbstractClassGenerator.create(AbstractClassGenerator.java:319)
    at org.springframework.cglib.proxy.Enhancer.createHelper(Enhancer.java:569)
    at org.springframework.cglib.proxy.Enhancer.createClass(Enhancer.java:416)
    at org.springframework.aop.framework.ObjenesisCglibAopProxy.createProxyClassAndInstance(ObjenesisCglibAopProxy.java:57)
    at org.springframework.aop.framework.CglibAopProxy.getProxy(CglibAopProxy.java:205)
    at org.springframework.aop.framework.ProxyFactory.getProxy(ProxyFactory.java:110)
    at org.springframework.context.annotation.ContextAnnotationAutowireCandidateResolver.buildLazyResolutionProxy(ContextAnnotationAutowireCandidateResolver.java:117)
    at org.springframework.context.annotation.ContextAnnotationAutowireCandidateResolver.getLazyResolutionProxyIfNecessary(ContextAnnotationAutowireCandidateResolver.java:52)
    at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:1172)
    at org.springframework.context.annotation.CommonAnnotationBeanPostProcessor.autowireResource(CommonAnnotationBeanPostProcessor.java:521)
    at org.springframework.context.annotation.CommonAnnotationBeanPostProcessor.getResource(CommonAnnotationBeanPostProcessor.java:497)
    at org.springframework.context.annotation.CommonAnnotationBeanPostProcessor$1.getTarget(CommonAnnotationBeanPostProcessor.java:461)
    at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:673)
    at cn.howarliu.AsyncTaskProducer$$EnhancerBySpringCGLIB$$ebe8dcee.sendMessage(<generated>)
    at cn.howarliu.service.impl.AsyncTaskServiceImpl.create(AsyncTaskServiceImpl.java:88)
    at cn.howarliu.service.impl.AsyncTaskServiceImpl$$FastClassBySpringCGLIB$$e8965ed3_3.invoke(<generated>)
    at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:218)
    at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:750)
    at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:163)
    at org.springframework.transaction.interceptor.TransactionInterceptor$$Lambda$3136/0x0000000801913040.proceedWithInvocation(Unknown Source)
    at org.springframework.transaction.interceptor.TransactionAspectSupport.invokeWithinTransaction(TransactionAspectSupport.java:295)
    at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:98)
    at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
    at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:689)
    at cn.howarliu.service.impl.AsyncTaskServiceImpl$$EnhancerBySpringCGLIB$$f9101846.create(<generated>)
    at cn.howarliu.AsyncTaskSupporter.create(AsyncTaskSupporter.java:27)
    at cn.howarliu.AsyncTaskSupporter.create(AsyncTaskSupporter.java:35)

分析問題

找代碼

順著線程棧找代碼，經過的代碼如下：

cn.howardliu.AsyncTaskSupporter

public static Long create(AsyncTaskCreateRequestDto request) {
    return AsyncTaskSupporter.getBean(AsyncTaskService.class)
            .create(request);
}

cn.howardliu.service.impl.AsyncTaskServiceImpl

@Resource
@Lazy
private AsyncTaskProducer asyncTaskProducer;

@Override
@Transactional(rollbackFor = Exception.class)
public Long create(AsyncTaskCreateRequestDto request) {
  // 其他邏輯……
    asyncTaskProducer.sendMessage(dataContract);
    // 其他邏輯……
}

cn.howardliu.AsyncTaskKafkaProducer

@Override
@Transactional(rollbackFor = Exception.class)
public void sendMessage(AsyncTaskDataContract contract) {
    // 這個方法的邏輯這里不展示了
}

分析原因

如果是有運行時生成類的情況，一定是標記了@Lazy注解的AsyncTaskProducer和@Transactional。

Spring會在運行時查找并創建@Lazy標記的bean，如果bean的方法用了@Transactional，會使用Cglib生成動態代理類。

生成動態代理類的核心代碼是org.springframework.aop.framework.CglibAopProxy，具體方法如下（可以重點關注createEnhancer()方法）：

@Override
public Object getProxy(@Nullable ClassLoader classLoader) {
    if (logger.isTraceEnabled()) {
        logger.trace("Creating CGLIB proxy: " + this.advised.getTargetSource());
    }

    try {
        Class<?> rootClass = this.advised.getTargetClass();
        Assert.state(rootClass != null, "Target class must be available for creating a CGLIB proxy");

        Class<?> proxySuperClass = rootClass;
        if (ClassUtils.isCglibProxyClass(rootClass)) {
            proxySuperClass = rootClass.getSuperclass();
            Class<?>[] additionalInterfaces = rootClass.getInterfaces();
            for (Class<?> additionalInterface : additionalInterfaces) {
                this.advised.addInterface(additionalInterface);
            }
        }

        // Validate the class, writing log messages as necessary.
        validateClassIfNecessary(proxySuperClass, classLoader);

        // Configure CGLIB Enhancer...
        Enhancer enhancer = createEnhancer();
        if (classLoader != null) {
            enhancer.setClassLoader(classLoader);
            if (classLoader instanceof SmartClassLoader &&
                    ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
                enhancer.setUseCache(false);
            }
        }
        enhancer.setSuperclass(proxySuperClass);
        enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
        enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
        enhancer.setStrategy(new ClassLoaderAwareUndeclaredThrowableStrategy(classLoader));

        Callback[] callbacks = getCallbacks(rootClass);
        Class<?>[] types = new Class<?>[callbacks.length];
        for (int x = 0; x < types.length; x++) {
            types[x] = callbacks[x].getClass();
        }
        // fixedInterceptorMap only populated at this point, after getCallbacks call above
        enhancer.setCallbackFilter(new ProxyCallbackFilter(
                this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
        enhancer.setCallbackTypes(types);

        // Generate the proxy class and create a proxy instance.
        return createProxyClassAndInstance(enhancer, callbacks);
    }
    catch (CodeGenerationException | IllegalArgumentException ex) {
        throw new AopConfigException("Could not generate CGLIB subclass of " + this.advised.getTargetClass() +
                ": Common causes of this problem include using a final class or a non-visible class",
                ex);
    }
    catch (Throwable ex) {
        // TargetSource.getTarget() failed
        throw new AopConfigException("Unexpected AOP exception", ex);
    }
}

protected Enhancer createEnhancer() {
    return new Enhancer();
}

看源碼不會有問題

從源碼分析，spring會判斷是否使用class緩存，如果是，不會重復創建，如果否，會重復創建。

默認會使用緩存，只有兩處邏輯會設定不用緩存：

啟動參數設置了cglib.useCache是false；
classloader用的是SmartClassLoader且類是可重加載的。

檢查第一種情況

先看第一個，從啟動參數看看有沒有這個變量，使用命令jinfo $pid | grep cglib，發現沒有相關參數。

檢查第二種情況

第二種情況屬于盲區，不知道怎么查。

九年義務教育告訴我，不會的題先跳過。

檢查其他可能得情況

如果源碼沒有問題，那就是運行時有問題，到線上看看運行時加載的CglibAopProxy類和我們看到的類是不是一樣的。

借助arthas的jad命令：

有問題的機器createEnhancer方法如下圖：

沒問題的機器createEnhancer方法如下圖：

發現類果然不同，有問題機器的類主動設置不適用緩存了。

現象命中，但是為什么？

可能性1：jar包版本不一致

unzip解壓fat-jar，找到spring-aop的包，發現版本是相同的。

其實這一個已經排除，但是還是不死心，萬一雖然版本相同，但是包內容不同呢？

再次解壓spring-aop的包，找到CglibAopProxy.class，通過javap -c -v反編譯：

protected org.springframework.cglib.proxy.Enhancer createEnhancer();
    descriptor: ()Lorg/springframework/cglib/proxy/Enhancer;
    flags: (0x0004) ACC_PROTECTED
    Code:
      stack=2, locals=1, args_size=1
         0: new           #77                 // class org/springframework/cglib/proxy/Enhancer
         3: dup
         4: invokespecial #78                 // Method org/springframework/cglib/proxy/Enhancer."<init>":()V
         7: areturn
      LineNumberTable:
        line 231: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       8     0  this   Lorg/springframework/aop/framework/CglibAopProxy;

能夠看到，反編譯后的邏輯是，先調用了Enhancer的init方法，即構造函數，然后就調用了areturn指令返回了結果。

所以，無論是jar的版本，還是jar中的內容，都是原來的return new Enhancer();。

可能性2：從別的jar包加載的CglibAopProxy

有問題的服務取到的類是別的包的，用arthas的sc命令看下：

[arthas@]$ sc -d org.springframework.aop.framework.CglibAopProxy
 class-info        org.springframework.aop.framework.CglibAopProxy
 code-source       file:/path/to/runner.jar!/BOOT-INF/lib/spring-aop-5.1.10.jar!/
 name              org.springframework.aop.framework.CglibAopProxy
 isInterface       false
 isAnnotation      false
 isEnum            false
 isAnonymousClass  false
 isArray           false
 isLocalClass      false
 isMemberClass     false
 isPrimitive       false
 isSynthetic       false
 simple-name       CglibAopProxy
 modifier
 annotation
 interfaces        org.springframework.aop.framework.AopProxy,java.io.Serializable
 super-class       +-java.lang.Object
 class-loader      +-org.springframework.boot.loader.LaunchedURLClassLoader@4aa21f9d
                     +-jdk.internal.loader.ClassLoaders$AppClassLoader@6a6824be
                       +-jdk.internal.loader.ClassLoaders$PlatformClassLoader@5ee0a0ae
 classLoaderHash   4aa21f9d

都是 spring-aop-5.1.10.jar 中類。

可能性3：加載類時代碼被改了

其實排除了上面兩種可能，就只剩下這一種可能了。

有問題的服務使用了HotswapAgent，找到HotswapAgent的源碼分析，終于找到了SpringPlugin類，其中有一段改寫createEnhancer方法的代碼：

@OnClassLoadEvent(classNameRegexp = "org.springframework.aop.framework.CglibAopProxy")
public static void cglibAopProxyDisableCache(CtClass ctClass) throws NotFoundException, CannotCompileException {
    CtMethod method = ctClass.getDeclaredMethod("createEnhancer");
    method.setBody("{org.springframework.cglib.proxy.Enhancer enhancer = new org.springframework.cglib.proxy.Enhancer();enhancer.setUseCache(false);return enhancer;}");
    LOGGER.debug("org.springframework.aop.framework.CglibAopProxy - cglib Enhancer cache disabled", new Object[0]);
}

找到這里，基本上可以確定就是這個插件的問題了。

解決問題

很多時候，提出問題、找到問題、分析問題是難點，解決問題反而是比較簡答的。比如上面的問題，我們有兩種解法：

方法一：既然是運行時加載bean出現了重復創建Cglib代理類的問題，那就直接刪除@Lazy注解，啟動服務時創建并注入bean，運行時就不存在創建bean的問題了；
方法二：刪除有問題的組件，等不再壓測的時候再加回來。

實際工作中也是，我是先把@Lazy注解去掉了，然后又耐心找問題。

這算是一個技巧，先解問題，不要成為阻塞點，然后找到問題原因，提升能力。換句話就是，先做該做的，再做想做的。

文末總結

責任編輯：武曉燕來源：看山的小屋

成人免费xxxxx在线视频软件_久久精品久久久_亚洲国产精品久久久_天天色天天色_亚洲人成一区_欧美一级欧美三级在线观看