转载

AspectJ切面实例模式与GC的探究

切面代码初探

通过AspectJ在编译期间生成代码，并根据我们的JointCut和Advice在目标位置进行代码的织入/插桩。所以第一个感兴趣的点就是插桩的代码生成的效果是怎么样的。

切入点的选择是可枚举的： Before, After, AfterReturning, AfterThrowing, and Around

常用的是在某一个方法执行前/后插入代码，用于插桩统计代码调用情况或者日志打点。根据调用时机又可以分为call还是execution。针对匹配的插入点还可以结合通配符，与或非等逻辑运算进行过滤。整个切面编程的细节其实很多，完整掌握可以去经常查阅AspectJ的开发手册 The AspectJTM 5 Development Kit Developer’s Notebook

本文不谈如何使用AspectJ，读者可以自行百度相关上手资料。我们主要通过分析来解答一下几个问题：

AspectJ切面的实现代码与GC
AspectJ的切面实现

切面实例与使用

默认生成的切面逻辑封装在一个单例对象中。有多个Aspect切面则会有多个单例。

@Aspect注解可以接受一个value参数，默认值为空“”代表单例模式。相关API说明可见java doc

/**
 * Aspect declaration
 *
 * @author Alexandre Vasseur
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Aspect {

    /**
     * @return the per clause expression, defaults to singleton aspect.
     * Valid values are "" (singleton), "perthis(...)", etc
     */
    public String value() default "";
}

可知通过赋值为 perthis(...) 即可实现非单例的实例效果。在一个Classloader中，单例从生到死都是不会被GC的，如果独立切面很多，则会出现很多单例，因此需要避免切面持有上下文或者大对象。

@Aspect
public class Foo {}

@Aspect("perthis(execution(* abc..*(..)))")
public class Foo {}

不使用注解，通过切面代码的等价写法如下：

public aspect Foo {}

public aspect Foo perthis(execution(* abc..*(..))) {}

切实代码

根据切面是否为单例实例模式，其生成的代码是不同的。下面看一下两种情况下生成的代码。

为了使得分析有些实际意义，首先定义插桩场景：

统计线程被start的调用情况，在有新的线程start时，打印出上下文

随意写了一个线程实例化+启动的逻辑如下所示：

private Thread newThread() {
  return new Thread();
}
// 在Thread的start调用前插桩
newThread().start();

@Aspect
public class ThreadAspectJ {

    @Pointcut("!within(cn.hacktons.core.DelayAspectJ)")
    public void ignore() {
    }

    @Pointcut("call(Thread+.new(..)) && ignore()")
    public void constructor() {
    }

    @Pointcut("call(void Thread+.start()) && ignore()")
    public void threadStart() {
    }

    @Pointcut("call(java.util.concurrent.ThreadPoolExecutor+.new(..)) && ignore()")
    public void executor() {
    }

    @Pointcut("call(static * java.util.concurrent.Executors.*(..))")
    public void executorsMethod() {
    }

    @Before("constructor() || threadStart() || executor() || executorsMethod()")
    public void beforeThreadNew(JoinPoint point) {
        Helper.enterMethod(point);
    }
}

singleton实例模式

经过ajc编译后，插桩的代码如下：

Thread newThread = newThread();
ThreadAspectJ.aspectOf().beforeThreadNew(Factory.makeJP(ajc$tjp_2, this, newThread));
newThread.start();

单例实例模式是默认值，因此无线额外配置，器插入的代码是在切入点调用aspectOf获取单例对象并执行我们编写的advice函数。

这个单例的初始化是在切面类的静态块中。

AspectJ切面实例模式与GC的探究

由于是单例，并且没有任何置空的逻辑，因此该切面一旦被引用，将在App的整个后续生命周期中支持存在并占用内存空间。可以通过Profiler和MAT观察GC后的内存对象加以验证，在本案例中，切面没有显式持有任何业务上的数据他的大小如下：

AspectJ切面实例模式与GC的探究

shallow size 8bytes
retained size 304bytes

其中shallow代表对象自身大小，retained还包括引用对象大小，可以认为是GC后能释放的空间。

AspectJ切面实例模式与GC的探究

如果存在多个切面类，对应的就存在多个单例。

PS: 这里的size和MAT有些差异, MAT中不同面板显示的shallow size也不尽相同，偏小的值从数据上看应该是取自objectSize

AspectJ切面实例模式与GC的探究

perthis实例模式

要修改默认的单例切面，需要为Aspect注解添加perthis(…)其中…指代切如点匹配规则。在本文案例中，可简单调整为如下

@Aspect("perthis(constructor() || threadStart() || executor() || executorsMethod())")

// 插桩代码逻辑
Thread newThread = newThread();
ThreadAspectJ.ajc$perObjectBind(this);
if (ThreadAspectJ.hasAspect(this)) {
  ThreadAspectJ.aspectOf(this).beforeThreadNew(Factory.makeJP(ajc$tjp_2, this, newThread));
}
newThread.start();

// 被插桩的类MainActivity
public class MainActivity extends AppCompatActivity implements C0844ajcMightHaveAspect {
  private transient /* synthetic */ ThreadAspectJ ajc$cn_hacktons_core_ThreadAspectJ$perObjectField;

  public /* synthetic */ ThreadAspectJ ajc$cn_hacktons_core_ThreadAspectJ$perObjectGet() {
    return this.ajc$cn_hacktons_core_ThreadAspectJ$perObjectField;
  }

  public /* synthetic */ void ajc$cn_hacktons_core_ThreadAspectJ$perObjectSet(ThreadAspectJ threadAspectJ) {
    this.ajc$cn_hacktons_core_ThreadAspectJ$perObjectField = threadAspectJ;
  }
}

插桩的代码含义比较直白：

调用了静态方法ajc$perObjectBind，并将当前对象的引用传入绑定
判断是否存在切面
获取切面实例对象，并执行advice函数beforeThreadNew

在这三步中，只有beforeThreadNew函数是我们显式编写的，其他都是ajc自动生成的模板代码。

可以看到被插桩的类被添加了一个继承关系，继承的接口为切面类中自动生成的C0844ajcMightHaveAspect。

我们看一下绑定函数的实现：

public static synchronized /* synthetic */ void ajc$perObjectBind(Object obj) {
    synchronized (ThreadAspectJ.class) {
        if ((obj instanceof C0844ajcMightHaveAspect) && ((C0844ajcMightHaveAspect) obj).ajc$cn_hacktons_core_ThreadAspectJ$perObjectGet() == null) {
            ((C0844ajcMightHaveAspect) obj).ajc$cn_hacktons_core_ThreadAspectJ$perObjectSet(new ThreadAspectJ());
        }
    }
}

在绑定函数中根据当前传入的对象是否已经绑定了切面实例，会进行一次切面初始化并执行setter。到这里我们基本了解了模板代码的思路，getter的使用也就比较简单了，通过aspectOf方法，传入被插桩的类实例，来获取其绑定的切面类。

我们把这块逻辑稍微整理下，可以得到如下的关系图：

AspectJ切面实例模式与GC的探究

因此针对 perthis 模式来说，一个插桩目标类中如果存在多个切面，那么这些切面共享同一个切面实例。

小结

基于对插桩生成代码的分析，可以得到的结论如下：

切面默认已单例实现，所以同一个Classloader下共享同一个实例对象，且不会被GC回收
如果切面类较多，并且使用时机比较单调，可以考虑使用perthis模式，随着被插桩对象释放可以被GC回收
不同实例模式下生成的模板代码略有差异，单例模式下模板代码更少；perthis模式下会生成协议接口，并自动集成&实现
除了上述两种模式在Aspect手册中还有pertypewithin模式，从文档来看与perthis差异主要在配置规则上？

参考

Chapter 9. An Annotation Based Development Style - Aspect Declarations
Chapter 9. An Annotation Based Development Style - aspectOf() and hasAspect() methods
Garbage collection of aspect instances

原文 http://blog.hacktons.cn/2020/05/06/aspectj-gc/

正文到此结束