为什么同一个静态字段在 dalvik 中有两个不同的 id？

Question

我正在编写自己的玩具 Dalvik VM，但我似乎无法弄清楚 dalvik 如何处理继承的静态字段。

考虑下面的java代码：

class Parent { static int parent_int = 10; }
class MyCode extends Parent {
    public static void main(String[] args){
        System.out.println(parent_int + 1);
    }
}

当用 javac 和 java 编译并运行时，它会打印11到控制台，正如人们所期望的那样。然而，当它被编译成 dalvik 时，该parent_int值被转化为sgetget 的语句field@0000，而在is的字段 id<clinit>的方法中。Parentparent_intfield@0001

在我的 Dalvik VM 实现中，这成为一个问题，因为即使类 和已经field@0000初始化，也没有初始化。Parentfield@0001

Dalvik VM 如何处理这个问题？它如何知道它们是相关的并且应该被视为相同？为什么它们一开始就变成了两个不同的领域，而它们本可以是一个领域呢？

Answer 1

简短回答：field@0000 和 field@0001 实际上是不同的引用。

更长：让我们一步一步地进行：

反编译：

[tmp]$ dextra  -j -d -D classes.dex
/* 0 */ class   Parent  {
 /** 1 Static Fields (not printed - use -f to print) **/
 /** 2 Direct Methods  **/
 static  void <clinit> () // Class Constructor
    {
    /* # of Registers: 1 */
    /* # of Instructions: 5 */
    /* 0000: Op 1300 0a00       const/16 v0, 0xa */
    v0 = 10; 
    /* 0002: Op 6700 0100       sput v0, ?@1 */
    Parent.parent_int = v0; // (Field@1)
    /* 0004: Op 0e00            return-void  */
    return;

    } // end <clinit>
  void <init> () // Constructor
    {
    /* # of Registers: 1 */
    /* # of Instructions: 4 */
    /* 0000: Op 7010 0500 0000  invoke-direct { v0 } */
    result = java.lang.Object.<init>(v0); // (Method@5(v0))
    /* 0003: Op 0e00            return-void  */
    return;

    } // end <init>
    }  // end class Parent
/* 1 */ class   MyCode extends Parent   {    /** 2 Direct Methods  **/
      void <init> () // Constructor
        {
        /* # of Registers: 1 */
        /* # of Instructions: 4 */
        /* 0000: Op 7010 0300 0000  invoke-direct { v0 } */
        result = Parent.<init>(v0); // (Method@3(v0))
        /* 0003: Op 0e00            return-void  */
        return;

        } // end <init>
     public static  void main (java.lang.String[])
        {
        /* # of Registers: 2 */
        /* # of Instructions: 19 */
        /* 0000: Op 6201 0200       sget-object v1, ?@2 */
        v1 = java.lang.System.out; // (Field@2)
        /* 0002: Op 6000 0000       sget v0, ?@0 */
        v0 = MyCode.parent_int; // (Field@0)
        /* 0004: Op d800 0001       add-int/lit8 v0, 1 */
        v0 +=  1;
        /* 0006: Op 6e20 0400 0100  invoke-virtual { v1, v0 } */
        result = java.io.PrintStream.println(java.lang.System.out, MyCode.parent_int); // (Method@4(v1, v0))
        /* 0009: Op 6201 0200       sget-object v1, ?@2 */
        v1 = java.lang.System.out; // (Field@2)
        /* 000b: Op 6000 0100       sget v0, ?@1 */
        v0 = Parent.parent_int; // (Field@1)
        /* 000d: Op d800 0001       add-int/lit8 v0, 1 */
        v0 +=  1;
        /* 000f: Op 6e20 0400 0100  invoke-virtual { v1, v0 } */
        result = java.io.PrintStream.println(java.lang.System.out, Parent.parent_int); // (Method@4(v1, v0))
        /* 0012: Op 0e00            return-void  */
        return;

        } // end main
    }  // end class MyCode

（这是您的代码，但在您的代码之后添加另一个“System.out.println(Parent.parent_int + 1);”）

现在，正如您所说，父项的 引用 field1，而主项则查看 @0。如果我们显示字段：

[tmp]$ dextra  -F classes.dex
         Field (0) Definer: LMyCode; Name: parent_int type: I Flags: 0x0 
         Field (1) Definer: LParent; Name: parent_int type: I Flags: 0x0 
         Field (2) Definer: Ljava/lang/System; Name: out type: Ljava/io/PrintStream; Flags: 0x0

我们看到字段 1 属于 Parent，字段 0 属于 MyCode。由于它们都是静态的，因此它们分别由每个类拥有：在 Dalvik 对 MyCode 进行内部初始化时（我们看不到，因为这是在运行时级别处理的，现在通过从 .ART 克隆影子），字段引用“static_int”被复制（从子级的影子，而不是父级） - 但对父级字段的进一步引用（如我添加的 system.out.println ）将寻址字段 1，而不是 0。

编辑：请注意，从类的角度来看，只有一个属于父级的字段：

类 0：父文件：MyCode.java 1 个静态字段 2 个直接方法 类 1：MyCode 扩展 LParent；文件：MyCode.java 2 直接方法

因此“parent_int”很大程度上由父类拥有。

请注意，您始终在这个或那个对象/类的上下文中引用该字段，因此如果不是为了优化。所以 - 严格来说，Dalvik 可以折叠两个字段（相同） - 但不会这样做，因为拥有这个看似“重复”字段的成本并不高，并且值得快速访问定义器。