深入 Java 初始化

类别:Java 点击:0 评论:0 推荐:

深入 Java 初始化

关于Java 初始化,有多文章都用了很大篇幅的介绍。经典的<<Thinking in java>>更是用了专门的
一章来介绍Java初始化。但在大量有代码实例后面,感觉上仍然没有真正深入到初始化的本质。

本文以作者对JVM的理解和自己的经验,对Java的初始化做一个比深入的说明,由于作者有水平限制,
以及JDK各实现版本的变化,可能仍然有不少错误和缺点。欢迎行家高手赐教。


要深入了解Java初始化,我们无法知道从程序流程上知道JVM是按什么顺序来执行的。了解JVM的执行
机制和堆栈跟踪是有效的手段。可惜的是,到目前为止。JDK1。4和JDK1。5在javap功能上却仍然存在
着BUG。所以有些过程我无法用实际的结果向你证明两种相反的情况(但我可以证明那确实是一个BUG)

<<Thinking in java>>(第三版)在第四章一开始的时候,这样来描述Java的初始化工作:
以下译文原文:
可以这样认为,每个类都有一个名为Initialize()的方法,这个名字就暗示了它得在使用之前调用,不幸
的是,这么做的话,用户就得记住要调用这个方法,java类库的设计者们可以通过一种被称为构造函数的
特殊方法,来保证每个对象都能得到被始化.如果类有构造函数,那么java就会在对象刚刚创建,用户还来
不及得到的时候,自动调用那个构造函数,这样初始化就有保障了。

我不知道原作者的描述和译者的理解之间有多大的差异,结合全章,我没有发现两个最关键的字"<clinit>"
和"<init>"。至少说明原作者和译者并没有真正说明JVM在初始化时做了什么,或者说并不了解JVM的初始化
内幕,要不然明明有这两个方法,却为什么要认为有一个事实上并不存在的"Initialize()"方法呢?


"<clinit>"和"<init>"方法在哪里?
这两个方法是实际存在而你又找不到的方法,也许正是这样才使得一些大师都犯晕。加上jdk实现上的一
些BUG,如果没有深入了解,真的让人摸不着北。

现在科学体系有一个奇怪的现象,那么庞大的体系最初都是建立在一个假设的基础是,假设1是正确的,
由此推导出2,再继续推导出10000000000。可惜的是太多的人根本不在乎2-100000000000这样的体系都
是建立在假设1是正确的基础上的。我并不会用“可以这样认为”这样的假设,我要确实证明"<clinit>"
和"<init>"方法是真真实实的存在的:

 package debug;
 public class MyTest{
  static int i = 100/0;
  public static void main(String[] args){
   Ssytem.out.println("Hello,World!");
  }
 }

执行一下看看,这是jdk1.5的输出:

java.lang.ExceptionInInitializerError
Caused by: java.lang.ArithmeticException: / by zero
 at debug.MyTest.<clinit>(Test.java:3)
Exception in thread "main"

请注意,和其它方法调用时产生的异常一样,异常被定位于debug.MyTest的<clinit>.


再来看:

package debug;
public class Test {
  Test(){
      int i = 100 / 0;
  }
  public static void main(String[] args) {
    new Test();
  }
}

jdk1.5输入:
Exception in thread "main" java.lang.ArithmeticException: / by zero
 at debug.Test.<init>(Test.java:4)
 at debug.Test.main(Test.java:7)

JVM并没有把异常定位在Test()构造方法中,而是在debug.Test.<init>。

当我们看到了这两个方法以后,我们再来详细讨论这两个“内置初始化方法”(我并不喜欢生造一些
非标准的术语,但我确实不知道如何规范地称呼他们)。

内置初始化方法是JVM在内部专门用于初始化的特有方法,而不是提供给程序员调用的方法,事实上
“<>”这样的语法在源程序中你连编译都无法通过。这就说明,初始化是由JVM控制而不是让程序员
来控制的。

类初始化方法:<clinit>
我没有从任何地方了解到<clinit>的cl是不是class的简写,但这个方法确实是用来对“类”进行初
始化的。换句话说它是用来初始化static上下文的。

在类装载(load)时,JVM会调用内置的<clinit>方法对类成员和静态初始化块进行初始化调用。它们
的顺序按照源文件的原文顺序。
我们稍微增加两行static语句:
package debug;
public class Test {
  static int x = 0;
  static String s = "123";
  static {
    String s1 = "456";
    if(1==1)
    throw new RuntimeException();
  }
  public static void main(String[] args) {
    new Test();
  }
}
然后进行反编译:
javap -c debug.Test

Compiled from "Test.java"
public class debug.Test extends java.lang.Object{
static int x;

static java.lang.String s;

public debug.Test();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return

public static void main(java.lang.String[]);
  Code:
   0:   new     #2; //class debug/Test
   3:   dup
   4:   invokespecial   #3; //Method "<init>":()V
   7:   pop
   8:   return

static {};
  Code:
   0:   iconst_0
   1:   putstatic       #4; //Field x:I
   4:   ldc     #5; //String 123
   6:   putstatic       #6; //Field s:Ljava/lang/String;
   9:   ldc     #7; //String 456
   11:  astore_0
   12:  new     #8; //class java/lang/RuntimeException
   15:  dup
   16:  invokespecial   #9; //Method java/lang/RuntimeException."<init>":()V
   19:  athrow

}
这里,我们不得不说,JDK在javap功能上的实现有一个BUG。static段的16标号,那里标识了异常
的位置发生在"<init>"方法中,而实际上这段程序运行时的输出却是:

java.lang.ExceptionInInitializerError
Caused by: java.lang.RuntimeException
 at debug.Test.<clinit>(Test.java:8)
Exception in thread "main"

但我们总可以明白,类初始化正是按照源文件中定义的原文顺序进行。先是声明

static int x;

static java.lang.String s;

然后对int x和String s进行赋值:
   0:   iconst_0
   1:   putstatic       #4; //Field x:I
   4:   ldc     #5; //String 123
   6:   putstatic       #6; //Field s:Ljava/lang/String;
执行初始化块的String s1 = "456";生成一个RuntimeException抛
   9:   ldc     #7; //String 456
   11:  astore_0
   12:  new     #8; //class java/lang/RuntimeException
   15:  dup
   16:  invokespecial   #9; //Method java/lang/RuntimeException."<init>":()V
   19:  athrow

要明白的是,"<clinit>"方法不仅是类初始化方法,而且也是接口初始化方法。并不是所以接口
的属性都是内联的,只有直接赋常量值的接口常量才会内联。而

[public static final] double d = Math.random()*100;

这样的表达式是需要计算的,在接口中就要由"<clinit>"方法来初始化。

 

下面我们再来看看实例初始化方法"<init>"

"<init>"用于对象创建时对对象进行初始化,当在HEAP中创建对象时,一旦在HEAP分配了空间。最
先就会调用"<init>"方法。这个方法包括实例变量的赋值(声明不在其中)和初始化块,以及构造
方法调用。如果有多个重载的构造方法,每个构造方法都会有一个对应的"<init>"方法。

同样,实例变量和初始化块的顺序也是按源文件的原文顺序执行,构造方法中的代码在最后执行:

package debug;
public class Test {
  int x = 0;
  String s = "123";
  {
    String s1 = "456";
    //if(1==1)
    //throw new RuntimeException();
  }

  public Test(){
    String ss = "789";
  }

  public static void main(String[] args) {
    new Test();
  }
}

javap -c debug.Test的结果:

Compiled from "Test.java"
public class debug.Test extends java.lang.Object{
int x;

java.lang.String s;

public debug.Test();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   aload_0
   5:   iconst_0
   6:   putfield        #2; //Field x:I
   9:   aload_0
   10:  ldc     #3; //String 123
   12:  putfield        #4; //Field s:Ljava/lang/String;
   15:  ldc     #5; //String 456
   17:  astore_1
   18:  ldc     #6; //String 789
   20:  astore_1
   21:  return

public static void main(java.lang.String[]);
  Code:
   0:   new     #7; //class debug/Test
   3:   dup
   4:   invokespecial   #8; //Method "<init>":()V
   7:   pop
   8:   return
}

如果在同一个类中,一个构造方法调用了另一个构造方法,那么对应的"<init>"方法就会调用另一
个"<init>",但是实例变量和初始化块会被忽略,否则它们就会被多次执行。

package debug;
public class Test {
  String s1 = rt("s1");
  String s2 = "s2";
 
  public Test(){
    s1 = "s1";
  }
  public Test(String s){
    this();
    if(1==1) throw new Runtime();
  }
  String rt(String s){
    return s;
  }
  public static void main(String[] args) {
    new Test("");
  }
}

反编译的结果:
Compiled from "Test.java"
public class debug.Test extends java.lang.Object{
java.lang.String s1;

java.lang.String s2;

public debug.Test();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   aload_0
   5:   aload_0
   6:   ldc     #2; //String s1
   8:   invokevirtual   #3; //Method rt:(Ljava/lang/String;)Ljava/lang/String;
   11:  putfield        #4; //Field s1:Ljava/lang/String;
   14:  aload_0
   15:  ldc     #5; //String s2
   17:  putfield        #6; //Field s2:Ljava/lang/String;
   20:  aload_0
   21:  ldc     #2; //String s1
   23:  putfield        #4; //Field s1:Ljava/lang/String;
   26:  return

public debug.Test(java.lang.String);
  Code:
   0:   aload_0
   1:   invokespecial   #7; //Method "<init>":()V
   4:   new     #8; //class java/lang/RuntimeException
   7:   dup
   8:   invokespecial   #9; //Method java/lang/RuntimeException."<init>":()V
   11:  athrow

java.lang.String rt(java.lang.String);
  Code:
   0:   aload_1
   1:   areturn

public static void main(java.lang.String[]);
  Code:
   0:   new     #10; //class debug/Test
   3:   dup
   4:   ldc     #11; //String
   6:   invokespecial   #12; //Method "<init>":(Ljava/lang/String;)V
   9:   pop
   10:  return

}


我们再一次看到了javap实现的bug,虽然有一个"<init>":(Ljava/lang/String;)V签名可以说明
每个构造方法对应一个不同<init>,但Runtime异常仍然被定位到了"<init>"()V的方法中:
invokespecial   #8; //Method java/lang/RuntimeException."<init>":()V,而在main方法中的
调用却明明是"<init>":(Ljava/lang/String;)V.

但是我们看到,由于Test(String s)调用了Test();所以"<init>":(Ljava/lang/String;)V不再对
实例变量和初始化块进次初始化:

public debug.Test(java.lang.String);
  Code:
   0:   aload_0
   1:   invokespecial   #7; //Method "<init>":()V
   4:   new     #8; //class java/lang/RuntimeException
   7:   dup
   8:   invokespecial   #9; //Method java/lang/RuntimeException."<init>":()V
   11:  athrow


而如果两个构造方法是相互独立的,则每个构造方法调用前都会执行实例变量和初始化块的调用:

package debug;
public class Test {
  String s1 = rt("s1");
  String s2 = "s2";
  {
    String s3 = "s3";
  }
  public Test() {
    s1 = "s1";
  }

  public Test(String s) {
    if (1 == 1)
      throw new RuntimeException();
  }

  String rt(String s) {
    return s;
  }

  public static void main(String[] args) {
    new Test("");
  }
}

反编译的结果:

Compiled from "Test.java"
public class debug.Test extends java.lang.Object{
java.lang.String s1;

java.lang.String s2;

public debug.Test();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   aload_0
   5:   aload_0
   6:   ldc     #2; //String s1
   8:   invokevirtual   #3; //Method rt:(Ljava/lang/String;)Ljava/lang/String;
   11:  putfield        #4; //Field s1:Ljava/lang/String;
   14:  aload_0
   15:  ldc     #5; //String s2
   17:  putfield        #6; //Field s2:Ljava/lang/String;
   20:  ldc     #7; //String s3
   22:  astore_1
   23:  aload_0
   24:  ldc     #2; //String s1
   26:  putfield        #4; //Field s1:Ljava/lang/String;
   29:  return

public debug.Test(java.lang.String);
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   aload_0
   5:   aload_0
   6:   ldc     #2; //String s1
   8:   invokevirtual   #3; //Method rt:(Ljava/lang/String;)Ljava/lang/String;
   11:  putfield        #4; //Field s1:Ljava/lang/String;
   14:  aload_0
   15:  ldc     #5; //String s2
   17:  putfield        #6; //Field s2:Ljava/lang/String;
   20:  ldc     #7; //String s3
   22:  astore_2
   23:  new     #8; //class java/lang/RuntimeException
   26:  dup
   27:  invokespecial   #9; //Method java/lang/RuntimeException."<init>":()V
   30:  athrow

java.lang.String rt(java.lang.String);
  Code:
   0:   aload_1
   1:   areturn

public static void main(java.lang.String[]);
  Code:
   0:   new     #10; //class debug/Test
   3:   dup
   4:   ldc     #11; //String
   6:   invokespecial   #12; //Method "<init>":(Ljava/lang/String;)V
   9:   pop
   10:  return

}

累了,先写到这里吧。

本文地址:http://com.8s8s.com/it/it13879.htm