奇怪而又无可厚非的类加载顺序

昨天看到这样一篇帖子，讨论类加载顺序的，也可以说是初始化顺序的，今天早上找不到了，本来想回复的，现在自己写博客回复了，呵呵

public class Singleton {
private static Singleton obj = new Singleton();
public static int counter1 ;
public static int counter2 = 0;
private Singleton()
{
counter1++;
counter2++;
}
public static Singleton getInstance()
{
return obj;
}
public static void main(String[] args) {
Singleton.getInstance();
System.out.println("obj.counter1=="+counter1);
System.out.println("obj.counter2=="+counter2);
}

}

我不了解为什么obj.counter1=1，obj.counter2=0.希望给我说说 

刚开始也很迷茫，我想不通的问题是什么时候声明的变量count1、count2？

以前的理解它的执行顺序应该是这样的:

1、加载类，当然首先执行的是

private static Singleton obj = new Singleton();

2、所以出现了对中对象的创建，于是执行构造方法：

private Singleton()
{
counter1++;
counter2++;
}

 3、按照顺序，应该执行下一条语句，即：

public static int counter1 ;
public static int counter2 = 0;

好了，类的加载过程完成了。

现在才开始执行main方法的第一条语句，随后的结论都成立了。

现在的问题出现了：什么时候声明的变量count1、count2？

 

查询了一些资料，终于解决了，我认为应该是这样的：

类加载的顺序其实以上的说法是有误的，也就是以前的理解是存在偏差的，除非出现想文章这样的程序才会暴露出来。好了，废话少说，看看真正的类加载顺序：

类加载分为三个过程：装载、链接、初始化。

 

装载的过程就是将class文件读入内存的过程，并且提取其中的类关键信息，比如：方法、变量等等。

 

而在链接中存在三个步骤：

a、进行字节码的检查，看是否符合class文件规范；

b、对类中的类变量进行分配空间，附初始值。此处专指基本类型。

c、对类中的引用变量进行分配空间。

 

随后才进行初始化，现在的初始化才是真正的，将按照语句一句一句执行了。

 

也就是说，在初始化执行以前所有的类变量以及引用变量都是分配了存储空间的，只是他们的数值是不可信任的，也就是系统默认的数据。

现在问题终于搞明白了。

 

所以有这样一个建议，或者说以前有人提醒的问题：

在进行构造方法中不允许进行业务逻辑的处理，只是进行简单的数据初始化，不然会出现意想不到的结果。

 

这个程序说明了这个问题。

如果将

private static Singleton obj = new Singleton();
public static int counter1 ;
public static int counter2 = 0;

 变换为

public static int counter1 ;
public static int counter2 = 0;
private static Singleton obj = new Singleton();

则执行结果则由

obj.counter1=1，obj.counter2=0

变成了

obj.counter1=1，obj.counter2=1.

 

这下明白了吧。

评论

34 楼 okhaoba 2009-07-15  

主要原因是：
public static int counter2 = 0;
并不是一个原子操作，但给人的印象总是声明和初始化同时完成。

33 楼 daoyongyu 2008-11-21  

  不错不错，书中只说静态变量与实例变量的区别和作用，而很小提到两者初始化顺序的对比；

其根本区别在于实例变量是各实例自已拥有和维护的变量，所以在构造前必须对其进行分配内存空间和初始化；而静态变量是各实例共同拥有和维护的，它被预先分配内存，并初始化；

而在楼主的程序中，按照执行顺序，类实例的构造方法首先执行，由于counter1、counter2是静态变量，已经预先存在内存中，所以执行完构告方法后，counter1=1, counter2=1；在接着执行的public  static int counter2 = 0; 中又重新给counter2赋值为0，所以counter2的值为0

====================================
楼上的说的没错！！！！！！

32 楼 jxausea 2008-11-17  

public class Singleton {
//public static int counter1=1 ;
//public static int counter2 = 1;

private static Singleton obj = new Singleton();
public static int counter1 =2;
public static int counter2 = 1;
private Singleton()
{
System.out.println("前counter1="+counter1);
System.out.println("前counter2="+counter2);

counter1++;
counter2++;
System.out.println("后counter1="+counter1);
System.out.println("后counter2="+counter2);

}
public static Singleton getInstance()
{
return obj;
}
public static void main(String[] args) {
System.out.println("--->开始类实例化之前");
Singleton.getInstance();
System.out.println("--->类实例化以后");
System.out.println("obj.counter1=="+counter1);
System.out.println("obj.counter2=="+counter2);
}

}
上述程序运行结果是：
前counter1=0
前counter2=0
后counter1=1
后counter2=1
--->开始类实例化之前
--->类实例化以后
obj.counter1==2
obj.counter2==1

31 楼 jxausea 2008-11-17  

public class Singleton {
public static int counter1=1 ;
public static int counter2 = 1;

private static Singleton obj = new Singleton();
//public static int counter1 =2;
//public static int counter2 = 1;
private Singleton()
{
System.out.println("前counter1="+counter1);
System.out.println("前counter2="+counter2);

counter1++;
counter2++;
System.out.println("后counter1="+counter1);
System.out.println("后counter2="+counter2);

}
public static Singleton getInstance()
{
return obj;
}
public static void main(String[] args) {
System.out.println("--->开始类实例化之前");
Singleton.getInstance();
System.out.println("--->类实例化以后");
System.out.println("obj.counter1=="+counter1);
System.out.println("obj.counter2=="+counter2);
}

}
上述程序运行结果：
前counter2=1
后counter1=2
后counter2=2
--->开始类实例化之前
--->类实例化以后
obj.counter1==2
obj.counter2==2

30 楼 wangdi 2008-11-17  

呵呵，实际的执行顺序是
1、先执行ClassLoadDemo()
2、然后执行counter2 = 0的赋值操作。
也就是说在ClassLoadDemo()执行完成的时候counter2和counter1的值都是1，然后再被赋值为0，如果后来赋值为2，那么结果就变成了counter2 = 2了。

29 楼 luzl 2008-11-15  

gao_20022002 写道

引用说的很对，我觉得这能够很好的解释lz代码中出现的现象。1.静态变量赋值是放在static{}块中实现2.static{}块中的赋值是按照变量声明顺序另外再加二点：3.类只初始化一次静态变量。4.static{}块最先执行在类中。所以：在执行main{}中的Singleton.getInstance();之前obj已经在前面提到的static块中赋值了.也就是在它之前已经执行：A.产生变量counter1,counter2,obj.其中counter1,counter2因为是int型默认0B.赋值：第一步：执行构造函数，使得counter1，counter2都变成.第二步：赋值counter1因为没有指定值所以不执行保留值1. 第三步：counter2 赋值为 0这一步getInstance()再没有调用构造函数，应为静态变量只初始化一次.其实这些解释和以前回复中出现的类似的解释都是正确的。我想告诉大家的问题是着重了解一下虚拟机加载类的过程，在你懂得了这个以后，再出现类似的问题就会有思考的方向，而不是仅仅针对一个问题。现在再次重申一下，类得加载过程：引用类的加载过程分为三步：装载、链接、初始化。装载的过程就是将class文件读入内存的过程，并且提取其中的类关键信息，比如：方法、变量等等。而在链接中存在三个步骤：a、进行字节码的检查，看是否符合class文件规范；b、对类中的类变量进行分配空间，附初始值。此处专指基本类型。c、对类中的引用变量进行分配空间。随后才进行初始化，现在的初始化才是真正的，将按照语句一句一句执行了。也就是说，在初始化执行以前所有的类变量以及引用变量都是分配了存储空间的，只是他们的数值是不可信任的，也就是系统默认的数据。真正明白了这些才是关键。

Good

28 楼 johan 2008-10-24  

这只是类加载中static变量的顺序，就是因为静态变量比较特殊，大家可以看下

public class ClassLoadTest {
	private static ClassLoadTest obj = new ClassLoadTest();
	public  int counter1;
	public  int counter2 = 0;

	private ClassLoadTest() {
		counter1++;
		counter2++;
	}

	public static ClassLoadTest getInstance() {
		return obj;
	}

	public static void main(String[] args) {
		ClassLoadTest cllo = ClassLoadTest.getInstance();
		System.out.println("obj.counter1==" + cllo.counter1);
		System.out.println("obj.counter2==" + cllo.counter2);
	}

}

在跑下结果就看出区别了。

27 楼 gao_20022002 2008-10-24  

引用

说的很对，我觉得这能够很好的解释lz代码中出现的现象。
1.静态变量赋值是放在static{}块中实现
2.static{}块中的赋值是按照变量声明顺序

另外再加二点：
3.类只初始化一次静态变量。
4.static{}块最先执行在类中。

所以：在执行main{}中的Singleton.getInstance();之前obj已经在前面提到的static块中赋值了.也就是在它之前已经执行：
A.产生变量counter1,counter2,obj.其中counter1,counter2因为是int型默认0
B.赋值：第一步：执行构造函数，使得counter1，counter2都变成.第二步：赋值counter1因为没有指定值所以不执行保留值1. 第三步：counter2 赋值为 0

这一步getInstance()再没有调用构造函数，应为静态变量只初始化一次.

其实这些解释和以前回复中出现的类似的解释都是正确的。

我想告诉大家的问题是着重了解一下虚拟机加载类的过程，在你懂得了这个以后，再出现类似的问题就会有思考的方向，而不是仅仅针对一个问题。

现在再次重申一下，类得加载过程：

引用

类的加载过程分为三步：装载、链接、初始化。

装载的过程就是将class文件读入内存的过程，并且提取其中的类关键信息，比如：方法、变量等等。

而在链接中存在三个步骤：

a、进行字节码的检查，看是否符合class文件规范；

b、对类中的类变量进行分配空间，附初始值。此处专指基本类型。

c、对类中的引用变量进行分配空间。

随后才进行初始化，现在的初始化才是真正的，将按照语句一句一句执行了。

也就是说，在初始化执行以前所有的类变量以及引用变量都是分配了存储空间的，只是他们的数值是不可信任的，也就是系统默认的数据。

真正明白了这些才是关键。

26 楼 luzl 2008-10-24  

aspnetking 写道

个人认为静态声明并赋值，赋值会实际体现在static{}语名块中，并且是按声明顺序赋值的。而静态初始化块又会在静态构造函数之后执行，所以会出现这种情况。可以把"public static int counter2 = 0; "向前移两行，可以看出打印结果都是1

说的很对，我觉得这能够很好的解释lz代码中出现的现象。
1.静态变量赋值是放在static{}块中实现
2.static{}块中的赋值是按照变量声明顺序

另外再加二点：
3.类只初始化一次静态变量。
4.static{}块最先执行在类中。

所以：在执行main{}中的Singleton.getInstance();之前obj已经在前面提到的static块中赋值了.也就是在它之前已经执行：
A.产生变量counter1,counter2,obj.其中counter1,counter2因为是int型默认0
B.赋值：第一步：执行构造函数，使得counter1，counter2都变成.第二步：赋值counter1因为没有指定值所以不执行保留值1. 第三步：counter2 赋值为 0

这一步getInstance()再没有调用构造函数，应为静态变量只初始化一次.

25 楼 aspnetking 2008-10-23  

个人认为静态声明并赋值，赋值会实际体现在static{}语名块中，并且是按声明顺序赋值的。而静态初始化块又会在静态构造函数之后执行，所以会出现这种情况。可以把"public static int counter2 = 0; "向前移两行，可以看出打印结果都是1

24 楼 aspnetking 2008-10-23  

通过调试发现：
若将"public static int counter2 = 0"向上移两行，会发现打印值都为1
各人认为情况是这样：
static

23 楼 programmer 2008-10-23  

我认为整个顺序是这样的：
1.加载整个类，把变量都分配空间。这是
counter1=0 
counter2=0
因为这两个变量是基本类型变量，我们独知道基本类型变量加载的时候java会自动赋予一定的值。
2.初始化：
先执行 obj = new Singleton(); 这个语句 这时候会执行构造函数 所以
counter1=1
counter2=1
然后继续往下初始化 但要注意了 这句代码：
public static int counter1 ; 并不执行 因为没有任何的付值动作 ，而是执行：
public static int counter2=0 ;

所以这是：
counter1=1
counter2=0

完全是个人的理解，我觉得楼主这个的主题还是很好的，好多开发人员平时都不考虑这些东西，也让我学了不少东西，希望楼主继续推走这种有深度的主题。我将继续关注

22 楼 gao_20022002 2008-10-23  

引用

原因真的如你所说的吗？我认为原因是在public  static int counter2 = 0;这个地方又重新赋值了而已。

你说的是对的，我把这个类加了两个打印语句就能清楚地看到结果。

其实是这样的。

但是都忘了关注类是如何加载的，了解了类加载机制会更容易接受一点。慢慢体会，不要只看到表面。
一切从规范定义开始。

21 楼 programmer 2008-10-23  

dlovek 写道

原因真的如你所说的吗？我认为原因是在public  static int counter2 = 0;这个地方又重新赋值了而已。

你说的是对的，我把这个类加了两个打印语句就能清楚地看到结果。
public class Singleton { 
private static Singleton obj = new Singleton(); 
public static int counter1 ; 
public static int counter2 = 0; 
private Singleton(){ 
counter1++; 
counter2++;
//counter1=counter1+1;
//counter2=counter2+1;
System.out.println("counter1="+counter1);
System.out.println("counter2="+counter2);
} 
public static Singleton getInstance(){ 
return obj; 
} 
public static void main(String[] args) { 
Singleton.getInstance(); 
System.out.println("obj.counter1="+counter1); 
System.out.println("obj.counter2="+counter2); 
}
} 

20 楼 programmer 2008-10-23  

我还是不明白

19 楼 icewubin 2008-10-23  

建议大家不要使用饿汉式初始化，如果要用的话，要确保初始化的代码在所有定义类变量的后面。

推荐类加载方式的延迟初始化的单例模式：

public class Singleton {
	private static class Holder {
		private static final Singleton instance = new Singleton();
	}
	public static Singleton getInstance() {
		return Holder.instance;
	}
}

18 楼 gao_20022002 2008-10-23  

引用

这个帖子以前有人发过，说是所有程序员都会犯的错误。

我也是新来javaeye的，对于这个就不知道了。

只要没看过的人有收获就好，看到过的权当复习了，顺便对有误解的地方提出指正，谢谢。

17 楼 harrison2010 2008-10-22  

这个帖子以前有人发过，说是所有程序员都会犯的错误。

16 楼 gao_20022002 2008-10-22  

引用

这个结果是一定发生的吗？
我感觉，不一定每次执行多少一样的结果。
因为jvm可以对非static得属性，可能进行优化，也就是说，初始化过程，不一定是按照顺序执行的，jvm会认为调换顺序对执行结果没有影响（虽然有时的确有影响，所以我们写代码的时候要注意）。

可能我们在平时测试不出来，但是如果拿到生产环境，这些问题可能就暴露了。

jvm对于非static属性的优化，这点还没有看到相关的说明或者文章，也不知道具体会是怎样。

现在在看jvm规范，还没有看到相关的问题说明，但是我相信类加载的策略是不会变化的，即使优化也不会改变执行顺序，只是实现方式或者执行效率问题。
就像文章中说的：类加载的三个过程装载、链接、初始化这个我想是不会变的，变的只是实现方式吧。

无论什么时候，像我们的单线程程序，我认为都是顺序执行的，当然初始化也是同样。

顺便说一下：也没有足够的测试，假如按照初始化策略实现方式不会变动的思路推下来的话，执行结果应该不会变化，在我的所有测试过程中还是很稳定的结果。

希望有了解这方面的人介绍介绍，我也没有充足的理由。
谢谢。

15 楼 zxming12345 2008-10-22  

dlovek 写道

gao_20022002 写道引用gao_20022002 写道引用原因真的如你所说的吗？我认为原因是在public  static int counter2 = 0;这个地方又重新赋值了而已。重新赋值？这就有点不可思议了，这个语句是重新赋值：public  static int counter2 = 0;这个主要的用途是声明一个变量吧，赋值只是为了说明与count1的区别。其实你没有看明白我的问题：在new时我怎么得到变量count1、 count2？不，因为counter1为默认值，而counter2却又被重新赋值过了。你可以将publi static int counter1;以及publi static int counter2 = 0;中的static去掉，将他们变成一般类变量，而不是静态的，再将刚才的那个Singleton obj = Singleton.getInstance()添加上，看看结果。这也是一个static与普通变量的区别。为什么会这样？去掉static后，couter1和counter2为实例属性，在调用构造之前会首先为实例属性分配内存空间，赋默认值，最后赋指定值，这些都完成之后才会执行构造内的语句。而static的counter1和counter2为类属性，它们的初始化是按照语句顺序执行的，所以调用构造之后，又会执行public static int counter2=0，这次会覆盖掉曾在构造方法内的值。不知道说明白没有。

这个结果是一定发生的吗？
我感觉，不一定每次执行多少一样的结果。
因为jvm可以对非static得属性，可能进行优化，也就是说，初始化过程，不一定是按照顺序执行的，jvm会认为调换顺序对执行结果没有影响（虽然有时的确有影响，所以我们写代码的时候要注意）。

可能我们在平时测试不出来，但是如果拿到生产环境，这些问题可能就暴露了。