Groovy深入探索——Metaclass的存放

本文介绍了Metaclass在Groovy中的存放方式，并对不同的情况(Per-class Metaclass、POGO Per-instance Metaclass和POJO Per-instance Metaclass)进行了分析。

注：以下分析的Groovy源代码来自Groovy 1.7.1，所有测试代码在Groovy 1.7.1下测试通过。

[size=x-large]Metaclass[/size]
用过Groovy的程序员都或多或少、直接或间接的接触过Metaclass。简单来说，Metaclass就是Class的Class，Class定义了该类实例的行为，Metaclass则定义了该类及其实例的行为([url]http://en.wikipedia.org/wiki/Metaclass[/url])。Groovy通过Metaclass使程序可以在运行时修改/添加类的方法、属性等。

[size=x-large]Per-class Metaclass[/size]
在Groovy中，每个Class都有一个对应的Metaclass，通过这个Metaclass可以给这个Class添加方法或属性：

// 给String类添加了一个名为capitalize的方法
String.metaClass.capitalize = { -> delegate[0].toUpperCase() + delegate[1..-1] }
// 给String类添加了一个名为spaceCount的只读属性
String.metaClass.getSpaceCount = { -> delegate.count(' ') }

assert "this is groovy".capitalize() == "This is groovy"
assert "this is not ruby".spaceCount == 3

除此之外，还可以替换Class对应的Metaclass：

def newMetaClass = new ExpandoMetaClass(Integer)
newMetaClass.initialize()
// 替换Integer类的Metaclass
Integer.metaClass = newMetaClass
assert Integer.metaClass == newMetaClass

但是，Class对应的Metaclass到底存放在哪里呢？

我们可以知道，Java的Class类中是没有存放Metaclass的属性的，而Groovy中的Class类就是Java中的Class类。那么，Groovy就需要一个全局的Map来存放每个Class对应的Metaclass了，其中每个Entry的key是Class，value则是Metaclass。这个全局的Map不需要对key(Class)进行排序，所以可以使用HashMap；应该通过是否是同一个实例来判断key的相等性，所以应该是一个IdentityHashMap；不应该妨碍Class被回收，而且Class被回收时对应的Metaclass也应该被回收，所以应该是一个WeakHashMap；可能被多个线程同时使用，所以应该是一个ConcurrentHashMap。总的来说，这个全局的Map应该是一个WeakIdentityConcurrentHashMap。

在Groovy中，这个全局的Map其实就是groovy.lang.MetaClassRegistry，不过在实现细节上有所区别(或者说更加复杂)。MetaClassRegistry是一个interface，它在Groovy中的唯一实现是org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl。我们主要来看MetaClassRegistryImpl中的getMetaClass方法，这个方法用于查找Class对应的Metaclass。

public final MetaClass getMetaClass(Class theClass) {
    return ClassInfo.getClassInfo(theClass).getMetaClass();
}

我们再来看看ClassInfo的getClassInfo静态方法：

public static ClassInfo getClassInfo(Class cls) {
    // localMapRef的类型是WeakReference<ThreadLocalMapHandler>
    ThreadLocalMapHandler handler = localMapRef.get();
    SoftReference<LocalMap> ref=null;
    if (handler!=null) ref = handler.get();
    LocalMap map=null;
    if (ref!=null) map = ref.get();
    if (map!=null) return map.get(cls);
    // 只有当localMapRef或ref已被回收时，才会调用下面的代码
    // globalClassSet的类型是ClassInfoSet
    return (ClassInfo) globalClassSet.getOrPut(cls,null);
}

ClassInfo中使用静态的globalClassSet存储Metaclass，不过并不是直接存储Class到Metaclass的映射，而是Class到ClassInfo的映射，而ClassInfo则包含了Groovy中跟Class相关的内部属性，其中就包括了Metaclass。

globalClassSet的类型是ClassInfoSet，而ClassInfoSet类继承了ManagedConcurrentMap<Class,ClassInfo>类型，而ManagedConcurrentMap其实就是Weak(Soft)IdentityConcurrentHashMap。限于篇幅，我们在这里就不分析ManagedConcurrentMap和ClassInfoSet的代码了。

再回到ClassInfo的getClassInfo方法，其中第3到8行实现了一个基于ThreadLocal的两级cache。我们先来看第5行的“handler.get()”，这里调用了ThreadLocalMapHandler的get方法：

private static class ThreadLocalMapHandler extends ThreadLocal<SoftReference<LocalMap>> {
    SoftReference<LocalMap> recentThreadMapRef; // 最近一次使用的引用
    ...
    public SoftReference<LocalMap> get() {
        SoftReference<LocalMap> mapRef = recentThreadMapRef;
        LocalMap recent = null;
        if (mapRef!=null) recent = mapRef.get();
        // 如果最近一次使用的引用就是由当前进程创建的，则直接返回该引用，否则才调用ThreadLocal的get方法。这样可以减少在ThreadLocal.get()中查找Map的消耗
        if (recent != null && recent.myThread.get() == Thread.currentThread()) {
            return mapRef;
        } else {
            SoftReference<LocalMap> ref = super.get();
            recentThreadMapRef = ref; // 更新最近一次使用的引用
            return ref;
        }
    }
}

再来看ClassInfo.getClassInfo(Class)中第8行的“map.get(cls)”，这里调用了LocalMap的get方法：

private static final class LocalMap extends HashMap<Class,ClassInfo> { // LocalMap本身就是二级cache
    private static final int CACHE_SIZE = 5;
    ...
    private final ClassInfo[] cache = new ClassInfo[CACHE_SIZE]; // 这是大小为5的一级cache
    ...
    public ClassInfo get(Class key) {
        ClassInfo info = getFromCache(key); // 先在一级cache中查找
        if (info != null)
          return info;

        info = super.get(key); // 再在二级cache中查找
        if (info != null)
          return putToCache(info); // 写入一级cache

        // 如果在两级cache中都找不到，则在globalClassSet中查找，再将结果写入一级cache
        return putToCache((ClassInfo) globalClassSet.getOrPut(key,null));
    }
    ...
}

注意，这里并没有将任何的结果写入到二级cache中，因此二级cache永远是空的。我认为这可能是被遗漏了，也可能是发现了二级cache占用了大量内存(或者效果并不明显)，所以将写入二级cache的语句去掉了，但是忘了去掉在二级cache中查找的语句。

最后，在MetaClassRegistryImpl.getMetaClass(Class)方法中，查找到Class对应的ClassInfo后，再调用ClassInfo的getMetaClass方法获得Class对应的Metaclass。但是ClassInfo.getMetaClass()并不是简单的返回Metaclass，其中还分为对Metaclass的强引用和弱引用两种情况。由于这已经超出了本文讨论的范围，因此不再深入，对此有兴趣的读者可阅读分析相关代码。

[size=x-large]POGO Per-instance Metaclass[/size]
POGO的全称是Plain Old Groovy Object，一般指的就是用Groovy编写的对象。每个POGO实例都有一个对应的Metaclass，默认情况下该Metaclass与类的Metaclass相同：

class POGO {} // 这是一个用Groovy编写的对象

def pogo = new POGO()
assert pogo.metaClass == POGO.metaClass // 默认情况下POGO实例的Metaclass与类的Metaclass相同

pogo.metaClass.hello = { -> println 'Hello' }
assert pogo.metaClass != POGO.metaClass // 修改POGO实例的Metaclass后，该POGO实例将拥有独立的Metaclass

我们通过groovyc编译上面的脚本，再通过javap反汇编POGO类，最后手工反编译字节码，可以得到以下代码：

public class POGO implements GroovyObject { // 用Groovy编写的类都实现了GroovyObject接口
    ...
    private transient MetaClass metaClass; // 用于存储实例对应的Metaclass
    ...
    public MetaClass getMetaClass() { // 实现了GroovyObject.getMetaClass()方法
        if (metaClass != null)
            return metaClass;
        metaClass = $getStaticMetaClass(); // 默认情况下返回类的Metaclass
        return metaClass;
    }

    public void setMetaClass(MetaClass metaClass) { // 实现了GroovyObject.setMetaClass(MetaClass)方法
        this.metaClass = metaClass;
    }

    protected MetaClass $getStaticMetaClass() {
        ClassInfo classinfo = $staticClassInfo;
        if (classinfo == null)
            $staticClassInfo = classinfo = ClassInfo.getClassInfo(getClass());
        return classinfo.getMetaClass();
    }
    ...
}

容易看出，POGO都实现了GroovyObject接口，而该接口中的getMetaClass和setMetaClass方法分别负责实例对应的Metaclass的读和写。而POGO实例对应的Metaclass则直接存放在实例中的metaClass字段中。

[size=x-large]POJO Per-instance Metaclass[/size]
与POGO类似的，POJO一般指的就是用Java编写的对象。自Groovy 1.6开始，可以为每个POJO实例设置不同的Metaclass了：

def s1 = "this is groovy"
def s2 = "this is not ruby"
assert s1.size() == 14
assert s2.size() == 16
s1.metaClass.size = { -> 10 } // 只修改s1的Metaclass
assert s1.size() == 10
assert s2.size() == 16

与Per-class Metaclass的情况一样(其实Class也是一个Java类)，POJO中并没有存放Metaclass的属性，所以需要用一个(或每个类一个)WeakIdentityConcurrentHashMap来存放Object到Metaclass的映射关系。

POJO Per-instance Metaclass是通过MetaClassRegistryImpl的getMetaClass(Object)和setMetaClass(Object, MetaClass)方法实现读和写的，但是这两个方法并没有加入到MetaClassRegistry接口中(可能是为了保持兼容性)。我们主要看一下MetaClassRegistryImpl.getMetaClass(Object)方法：

public MetaClass getMetaClass(Object obj) {
    return ClassInfo.getClassInfo(obj.getClass()).getMetaClass(obj);
}

跟getMetaClass(Class)方法一样，先通过ClassInfo.getClassInfo(Class)方法查找ClassInfo实例。接着调用了ClassInfo.getMetaClass(Object)方法，我们来看看这个方法：

public MetaClass getMetaClass(Object obj) {
    final MetaClass instanceMetaClass = getPerInstanceMetaClass(obj);
    if (instanceMetaClass != null)
        return instanceMetaClass;

    // 如果没有为该对象设置Metaclass，则返回类的Metaclass，即默认的Metaclass就是类的Metaclass
    lock();
    try {
        return getMetaClassUnderLock();
    } finally {
        unlock();
    }
}

public MetaClass getPerInstanceMetaClass(Object obj) {
    if (perInstanceMetaClassMap == null)
      return null;

    return (MetaClass) perInstanceMetaClassMap.get(obj);
}

getMetaClass(Object)方法先从perInstanceMetaClassMap属性中查找obj对应的Metaclass，而perInstanceMetaClassMap属性的类型是ManagedConcurrentMap，没错，就是我们上面提到过的Weak(Soft)IdentityConcurrentHashMap的实现。

也就是说，POJO对应的Metaclass是存放在它的Class对应的ClassInfo中的一个ManagedConcurrentMap中的。

[size=x-large]总结[/size]
总的来说，在各种情况下，Metaclass的存放方式如下：
[list]
[*]Per-class Metaclass：存放在Class对应的ClassInfo中，而Class到ClassInfo的映射关系则存放在ClassInfo中的一个静态的ManagedConcurrentMap中；
[*]POGO Per-instance Metaclass：直接存放在对象的metaClass字段中。
[*]POJO Per-instance Metaclass：对象到Metaclass的映射关系存放在该对象的Class对应的ClassInfo中的一个ManagedConcurrentMap中。
[/list]以上分析有不当之处敬请指出，谢谢大家的阅读。