一、初始化阶段

初始化阶段，简言之，为类的静态变量赋予正确的初始值。

1.1、具体描述

类的初始化是类装载的最后一个阶段。如果前面的步骤都没有问题，那么表示类可以顺利装载到系统中。此时，类才会开始执行Java字节码。(即:到了初始化阶段，才真正开始执行类中定义的Java程序代码。)

初始化阶段的重要工作是执行类的初始化方法:()方法。

  • 该方法仅能由Java编译器生成并由JVM调用，程序开发者无法自定义一个同名的方法，更无法直接在Java程序中调用该方法，虽然该方法也是由字节码指令所组成。
  • 它是由类静态成员的赋值语句以及static语句块合并产生的。

image.png

1.2、说明

1.2.1 在加载一个类之前，虚拟机总是会试图加载该类的父类，因此父类的总是在子类cclinit>之前被调用。也就是说，父类的static块优先级高于子类。
口诀:由父及子，静态先行。
image.png
输出结果：
image.png
1.2.2 Java编译器并不会为所有的类都产生()初始化方法。哪些类在编译为字节码后，字节码文件中将不会包含()方法?

  • 一个类中并没有声明任何的类变量，也没有静态代码块时。
  • 一个类中声明类变量，但是没有明确使用类变量的初始化语句以及静态代码块来执行初始化操作时。
  • 一个类中包含static final修饰的基本数据类型的字段，这些类字段初始化语句采用编译时常量表达式。

image.png

二、static与final的搭配问题

2.1、难度剖析

  1. /**
  2. 说明:使用static + final修饰的字段的显式赋值的操作，到底是在哪个阶段进行的赋值?
  3. 情况1:在链接阶段的准备环节赋值
  4. 情况2:在初始化阶段<clinit>()赋值
  5. 结论:
  6. 在链接阶段的准备环节赋值的情况:
  7. 1．对于基本数据类型的字段来说，如果使用static final修饰，则显式赋值(直接赋值常量，而非调用方法)通常是在链接阶段的准备环节进行
  8. 2，对于String来说，如果使用字面量的方式赋值，使用static finaL修饰的话，则显式赋值通常是在链接阶段的准备环节进行
  10. 在初始化阶段<clinit>()中赋值的情况:
  11. 排除上述的在准备环节赋值的情况之外的情况。
  13. 最终结论:使用static t finaL修饰，且显示赋值中不涉及到方法或构造器调用的基本数据类型或String类型的显式赋值，
  14. 是在链接阶段的准备环节进行。
  15. */
  16. public class InitilizationTest1 {
  17.     public static int a = 1;//在初始化阶段<clinit>()赋值
  18.     public static final int INT_CONSTANT = 10;//在链接阶段的准备环节赋值
  19.     public static final Integer INTEGER_CONSTANT1 = Integer.valueOf(100);//在初始化阶段<clinit>()赋值
  20.     public static Integer INTEGER_CONSTANT2 = Integer.valueOf(1000);//在初始化阶段<clinit>()赋值
  21.     public static final string s0 = "helloworld01";//在链接阶段的准备环节赋值
  22.     public static final String s1 = new String("helloworld02");//在初始化阶段<clinit>()赋值
  23. }
  24. #############################
  25. <clinit>方法下的字节码指令
  26.  0 iconst_1
  27.  1 putstatic #2 <studies/classloader/LoadingTest.a>
  28.  4 bipush 100
  29.  6 invokestatic #3 <java/lang/Integer.valueOf>
  30.  9 putstatic #4 <studies/classloader/LoadingTest.INTEGER_CONSTANT1>
  31. 12 sipush 1000
  32. 15 invokestatic #3 <java/lang/Integer.valueOf>
  33. 18 putstatic #5 <studies/classloader/LoadingTest.INTEGER_CONSTANT2>
  34. 21 new #6 <java/lang/String>
  35. 24 dup
  36. 25 ldc #7 <helloworld02>
  37. 27 invokespecial #8 <java/lang/String.<init>>
  38. 30 putstatic #9 <studies/classloader/LoadingTest.s1>
  39. 33 return

从字节码层面看，只有INTEGER_CONSTANT1和s0是在链接阶段的准备环节赋值
image.png
总体来说在static加final的的基本数据类型并且没有创建对象的情况下的赋值和字符串字面量形式赋值的都是在链接阶段的准备环节赋值，其它的static修饰的都是在中进行赋值

三、()的线程安全性

3.1、说明

对于()方法的调用，也就是类的初始化，虚拟机会在内部确保其多线程环境中的安全性。

image.pngclinit是隐式的锁，所以没有将synchronized体现出来

虚拟机会保证一个类的()方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的()方法，其他线程都需要阻塞等待，直到活动线程执行()方法完毕。

正是因为函数()带锁线程安全的，因此，如果在一个类的()方法中有耗时很长的操作，就可能造成多个线程阻塞，引发死锁。并且这种死锁是很难发现的，因为看起来它们并没有可用的锁信息。

如果之前的线程成功加载了类，则等在队列中的线程就没有机会再执行()方法了。那么，当需要使用这个类时，虚拟机会直接返回给它已经准备好的信息。

3.2、举例

  1. /**
  2. 以下代码中当线程去初始化StaticA的时候，v又在初始化StaticB因为clinit是线程安全的，
  3. 在初始化StaticA正在初始化clinit,这个时候StaticB也在初始化clinit，
  4. clinit处于阻塞状态，这样就会导致死锁。
  5. */
  6. package studies.statics;
  7. class StaticA{
  8.     static {
  9.         try {
  10.             Thread.sleep(1000);
  11.         } catch (InterruptedException e) {
  12.             e.printStackTrace();
  13.         }
  14.         try {
  15.             Class.forName("studies.statics.StaticB");
  16.         } catch (ClassNotFoundException e) {
  17.             e.printStackTrace();
  18.         }
  19.         System.out.println("StaticA init ok");
  20.     }
  21. }
  22. class StaticB{
  23.     static {
  24.         try {
  25.             Thread.sleep(1000);
  26.         } catch (InterruptedException e) {
  27.             e.printStackTrace();
  28.         }
  29.         try {
  30.             Class.forName("studies.statics.StaticA");
  31.         } catch (ClassNotFoundException e) {
  32.             e.printStackTrace();
  33.         }
  34.         System.out.println("StaticB init ok");
  35.     }
  37. }
  38. public class StaticDeadLockMain extends Thread{
  39.     private char flag;
  41.     public StaticDeadLockMain(char flag) {
  42.         this.flag = flag;
  43.     }
  45.     @Override
  46.     public void run() {
  47.         try {
  48.             Class.forName("studies.statics.Static"+flag);
  49.         } catch (ClassNotFoundException e) {
  50.             e.printStackTrace();
  51.         }
  52.         System.out.println(getName()+" over");
  53.     }
  55.     public static void main(String[] args) {
  56.         StaticDeadLockMain loadA = new StaticDeadLockMain('A');
  57.         loadA.start();
  58.         StaticDeadLockMain loadB = new StaticDeadLockMain('B');
  59.         loadB.start();
  60.     }
  61. }

四、类的初始化情况：主动使用vs被动使用

Java程序对类的使用分为两种:主动使用和被动使用。
如果针对代码，设置参数-XX:+TraceClassLoading，可以追踪类的加载信息并打印出来。

4.1、主动使用

4.1.1、说明

Class只有在必须要首次使用的时候才会被装载，Java虚拟机不会无条件地装载Class类型。Java虚拟机规定，一个类或接口在初次使用前，必须要进行初始化。这里指的“使用”，是指主动使用，主动使用只有下列几种情况:(即:如果出现如下的情况，则会对类进行初始化操作。而初始化操作之前的加载、验证、准备己经完成。)

  1. 当创建一个类的实例时，比如使用new关键字，或者通过反射、克隆、反序列化。
  2. 当调用类的静态方法时，即当使用了字节码invokestatic指令。
  3. 当使用类、接口的静态字段时(final修饰特殊考虑)，比如，使用getstatic或者putstatic指令。(对应访问变量、赋值变量操作)。
  4. 当使用java.lang.reflect包中的方法反射类的方法时。比如: Class.forName(“ com.atguigu.java.Test”)。
  5. 当初始化子类时，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。
  6. 如果一个接口定义了default方法，那么直接实现或者间接实现该接口的类的初始化，该接口要在其之前被初始化。
  7. 当虚拟机启动时，用户需要指定一个要执行的主类〈包含main()方法的那个类），虚拟机会先初始化这个主类。
  8. 当初次调用MethodHandle实例时，初始化该MethodHandle 指向的方法所在的类。（涉及解析REF_getStatic、REF_putStatic、REF_invokeStatic方法句柄对应的类)。

针对5，补充说明:
当Java虚拟机初始化一个类时，要求它的所有父类都已经被初始化，但是这条规则并不适用于接口。
>在初始化一个类时，并不会先初始化它所实现的接口
>在初始化一个接口时，并不会先初始化它的父接口
因此，一个父接口并不会因为它的子接口或者实现类的初始化而初始化。只有当程序首次使用特定接口的静态字段时，才会导致该接口的初始化。

4.1.2、举例

测试类的主动使用：意味着就会调用()方法，即执行了类的初始化

  1. package studies.statics;
  2. /**
  3.  * 1、当创建一个类的实例时，比如使用new关键字，或者通过反射、克隆、反序列化。
  4.  */
  5. public class ActiveUser1 {
  6.     public static void main(String[] args) {
  7.         Order order = new Order();
  8.     }
  10.     //序列化的过程
  11.     @Test
  12.     public void test1(){
  13.         ObjectOutputStream oos = null;
  15.         try {
  16.             oos = new ObjectOutputStream(new FileOutputStream("order.dat"));
  17.             oos.writeObject(new Order2());
  18.         } catch (IOException e) {
  19.             e.printStackTrace();
  20.         }finally {
  21.             try {
  22.                 if (oos != null){
  23.                     oos.close();
  24.                 }
  25.             } catch (IOException e) {
  26.                 e.printStackTrace();
  27.             }
  28.         }
  29.     }
  30.     //反序序列化的过程：（验证）
  31.     @Test
  32.     public void test2(){
  33.         ObjectInputStream ois = null;
  34.         try {
  35.             ois = new ObjectInputStream(new FileInputStream("order.dat"));
  36.             Order2 order = (Order2)ois.readObject();
  37.         } catch (IOException | ClassNotFoundException e) {
  38.             e.printStackTrace();
  39.         }finally {
  40.             if (ois != null){
  41.                 try {
  42.                     ois.close();
  43.                 } catch (IOException e) {
  44.                     e.printStackTrace();
  45.                 }
  46.             }
  47.         }
  48.     }
  49. }
  50. class Order{
  51.     static {
  52.         System.out.println("Order类的初始化过程");
  53.     }
  54. }
  55. ######################
  56. 控制台输出结果：
  57. Order类的初始化过程
  59. class Order2 implements Serializable {
  60.     static {
  61.         System.out.println("Order2类通过序列化进行初始化过程");
  62.     }
  63. }

  1. /**
  2. 2、当调用类的静态方法时，即当使用了字节码invokestatic指令
  3. static修饰的方法不会出现在<clinit>方法，静态方法只有在主动调的时候才会执行
  4. */
  5. class Order{
  6.     static {
  7.         System.out.println("Order类的初始化过程");
  8.     }
  9.     public static void method(){
  10.         System.out.println("Order method()");
  11.     }
  12. }
  13. public class ActiveUser1 {
  14.     @Test
  15.     public void test2(){
  16.         Order.method();
  17.     }
  18. }
  19. ########################
  20. 控制台输出：
  21. Order类的初始化过程
  22. Order method()
  1. package studies.statics;
  2. import org.junit.Test;
  4. /**
  5.  *3、当使用类、接口的静态字段时(final修饰特殊考虑)，比如，使用getstatic或者putstatic指令。(对应访问变量、赋值变量操作)。
  6.  */
  7. //例子1
  8. public class ActiveUser2 {
  10.     @Test
  11.     public void test1(){
  12.         System.out.println(User.num);
  13.     }
  15. }
  16. class User{
  17.     public static int num = 1;
  18.     static {
  19.         System.out.println("User类的初始化过程");
  20.     }
  21. }
  22. ########################
  23. 控制台输出：
  24. User类的初始化过程
  25. 1
  26. //-------------------------------------------------------
  27. //例子2，如果只是调取static + final的直接字面量，是不会触发类(<clinit>)初始化
  28. public class ActiveUser2 {
  30.     @Test
  31.     public void test1(){
  32.         System.out.println(User.NUM2);//是不会触发类(<clinit>)初始化
  33.         //System.out.println(User.NUM3);会触发类(<clinit>)初始化,因为调取了方式
  34.     }
  36. }
  37. class User{
  38.     public static int num = 1;
  39.     static {
  40.         System.out.println("User类的初始化过程");
  41.     }
  42.     public static final int NUM2 = 5;
  43.     //public static final int NUM3 = new Random().nextInt(5);
  44. }
  45. ########################
  46. 控制台输出：
  47. 5
  50. //---------------------------------------------------------------
  51. //例子3
  52. public class ActiveUser2 {
  54.     @Test
  55.     public void test2(){
  56.         System.out.println(CompareA.NUM1);//不会输出"CompareA的初始化"
  57.         System.out.println(CompareA.NUM2);//会输出"CompareA的初始化"
  58.     }
  60. }
  61. interface CompareA{
  63.     public static final Thread thred = new Thread(){
  64.         {
  65.             System.out.println("CompareA的初始化");
  66.         }
  67.     };
  68.     public static final int NUM1 = 1;
  69.     public static final int NUM2 = new Random().nextInt(5);
  70. }
  1. /**
  2. 4、当使用java.lang.reflect包中的方法反射类的方法时。比如: Class.forName("studies.statics.Order3")。
  3. */
  4. public class ActiveUser2 {
  5.     @Test
  6.     public void test1(){
  8.         try {
  9.             Class clazz = Class.forName("studies.statics.Order3");
  10.         } catch (ClassNotFoundException e) {
  11.             e.printStackTrace();
  12.         }
  13.     }
  15. }
  16. class Order3{
  17.     static {
  18.         System.out.println("Order类的初始化过程");
  19.     }
  20.     public static void method(){
  21.         System.out.println("Order method()");
  22.     }
  23. }
  24. ########################
  25. 控制台输出：
  26. Order类的初始化过程
  1. package studies.statics;
  2. import org.junit.Test;
  3. /**
  4.  * 当初始化子类时，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。
  5.  */
  6. public class ActiveUser2 {
  7.     @Test
  8.     public void test1(){
  9.         System.out.println(Son.num);
  10.     }
  12. }
  13. class Father{
  14.     static {
  15.         System.out.println("Father的初始化");
  16.     }
  17. }
  18. class Son extends Father{
  19.     static {
  20.         System.out.println("Son的初始化");
  21.     }
  22.     public static  int num = 1;
  23. }
  24. ########################
  25. 控制台输出：
  26. Father的初始化
  27. Son的初始化
  28. 1

如果针对代码，设置参数-XX:+TraceClassLoading，可以追踪类的加载信息并打印出来。
image.png
或者
image.png
image.png
可以看到父类Father的加载
image.png

  1. package studies.statics;
  2. import org.junit.Test;
  3. /**
  4. 针对5，补充说明:
  5. 当Java虚拟机初始化一个类时，要求它的所有父类都已经被初始化，但是这条规则并不适用于接口。
  6. >在初始化一个类时，并不会先初始化它所实现的接口
  7. >在初始化一个接口时，并不会先初始化它的父接口
  8. 因此，一个父接口并不会因为它的子接口或者实现类的初始化而初始化。只有当程序首次使用特定接口的静态字段时，才会导致该接口的初始化。
  9.  */
  10. public class ActiveUser2 {
  11.     @Test
  12.     public void test1(){
  13.         System.out.println(Son.num);
  14.     }
  15. }
  16. class Father{
  17.     static {
  18.         System.out.println("Father的初始化");
  19.     }
  20. }
  21. class Son extends Father implements CompareB{
  22.     static {
  23.         System.out.println("Son的初始化");
  24.     }
  25.     public static  int num = 1;
  26. }
  27. interface CompareB{
  28.     public static final Thread thred = new Thread(){
  29.         {
  30.             System.out.println("CompareA的初始化");
  31.         }
  32.     };
  33. }
  34. ########################
  35. 控制台输出：
  36. Father的初始化
  37. Son的初始化
  38. 1

可以看看出CompareB加载了，但没有被初始化
image.png

  1. package studies.statics;
  2. import org.junit.Test;
  3. /**
  4. 针对5，补充说明:
  5. 当Java虚拟机初始化一个类时，要求它的所有父类都已经被初始化，但是这条规则并不适用于接口。
  6. >在初始化一个类时，并不会先初始化它所实现的接口
  7. >在初始化一个接口时，并不会先初始化它的父接口
  8. 因此，一个父接口并不会因为它的子接口或者实现类的初始化而初始化。只有当程序首次使用特定接口的静态字段时，才会导致该接口的初始化。
  9.  */
  10. public class ActiveUser2 {
  11.     @Test
  12.     public void test1(){
  13.         System.out.println(CompareC.NUM1);
  14.     }
  15. }
  16. interface CompareB{
  17.     public static final Thread thred = new Thread(){
  18.         {
  19.             System.out.println("CompareA的初始化");
  20.         }
  21.     };
  22. }
  23. interface CompareC extends CompareB{
  24.     public static final Thread thred = new Thread(){
  25.         {
  26.             System.out.println("CompareC的初始化");
  27.         }
  28.     };
  29.     public static final int NUM1 = new Random().nextInt();
  30. }
  31. //父接口不会被初始化
  32. ########################
  33. 控制台输出：
  34. CompareC的初始化
  1. package studies.statics;
  2. import org.junit.Test;
  3. /**
  4.  * 如果一个接口定义了default方法，那么直接实现或者间接实现该接口的类的初始化，该接口要在其之前被初始化。
  5.  */
  6. public class ActiveUser2 {
  7.     @Test
  8.     public void test1(){
  9.         System.out.println(Son.num);
  10.     }
  11. }
  12. class Father{
  13.     static {
  14.         System.out.println("Father的初始化");
  15.     }
  16. }
  17. class Son extends Father implements CompareB{
  18.     static {
  19.         System.out.println("Son的初始化");
  20.     }
  21.     public static  int num = 1;
  22. }
  23. interface CompareB{
  24.     public static final Thread thred = new Thread(){
  25.         {
  26.             System.out.println("接口CompareB的初始化");
  27.         }
  28.     };
  29.     //带default标识的方法会导致接口初始化
  30.     public default void method1(){
  31.         System.out.println("method1！你好");
  32.     }
  33. }
  34. ########################
  35. 控制台输出：
  36. Father的初始化
  37. 接口CompareB的初始化
  38. Son的初始化
  39. 1

4.2、被动使用

4.2.1 说明

除了以上的情况属于主动使用，其他的情况均属于被动使用。被动使用不会引起类的初始化。
也就是说:并不是在代码中出现的类，就一定会被加载或者初始化。如果不符合主动使用的条件，类就不会初始化。

  1. 当访问一个静态字段时，只有真正声明这个字段的类才会被初始化。
    • 当通过子类引用父类的静态变量，不会导致子类初始化。(注意，虽然子类没有执行初始化，但子类已经完成加载阶段)
  2. 通过数组定义类引用,不会触发此类的初始化。
  3. 引用常量不会触发此类或接口的初始化。因为常量在链接阶段就已经被显式赋值了。

  4. 调用ClassLoader类的loadClass()方法加载一个类，并不是对类的主动使用，不会导致类的初始化。

    4.2.2 举例

    关于类的被动使用，即不会进行类的初始化操作，即不会调用()

    1. package studies.statics;
    2. import org.junit.Test;
    3. /**
    4. * 1. 当访问一个静态字段时，只有真正声明这个字段的类才会被初始化。
    5. *    • 当通过子类引用父类的静态变量，不会导致子类初始化。(注意，虽然子类没有执行初始化，但子类已经完成加载阶段)
    6. * 2. 通过数组定义类引用,不会触发此类的初始化。
    7. */
    8. public class PassiveUser1 {
    9.  @Test
    10.  public void test1(){
    11.      System.out.println(Child.num);//测试子类不会被初始化
    12.  }
    14.  @Test
    15.  public void test2(){
    16.      Parent[] parents = new Parent[10];//数组不会触发初始化，所以Parent类不会被初始化
    17.  }
    18. }
    19. class Parent{
    20.  static {
    21.      System.out.println("Parent的初始化过程");
    22.  }
    23.  public static int num = 1;
    24. }
    25. class Child extends Parent{
    26.  static {
    27.      System.out.println("Child的初始化过程");
    28.  }
    29. }
    30. ########################
    31. 控制台输出：
    32. Parent的初始化过程
    33. 1
    34. 说明子类不会被初始化，但子类已经被加载了
    1. package studies.statics;
    2. import org.junit.Test;
    3. /**
    4. * 3. 引用常量不会触发此类或接口的初始化。因为常量在链接阶段就已经被显式赋值了。
    5. * 4. 调用ClassLoader类的loadClass()方法加载一个类，并不是对类的主动使用，不会导致类的初始化。
    6. */
    7. public class PassiveUser1 {
    8.  @Test
    9.  public void test1(){
    10.      System.out.println(Person.NUM);
    11.  }
    12.  @Test
    13.  public void test2(){
    14.      try {
    15.          //这种方式调取一个类也不会执行<clinit>，这属于被动使用，
    16.          //而Class.forName("studies.statics.Person")属于主动使用
    17.          Class clazz = ClassLoader.getSystemClassLoader().loadClass("studies.statics.Person");
    18.      } catch (ClassNotFoundException e) {
    19.          e.printStackTrace();
    20.      }
    21.  }
    22. }
    23. class Person{
    24.  static {
    25.      System.out.println("Person的初始化过程");
    26.  }
    27.  public static final int NUM = 1;//在链接过程的准备环节就被赋值为1了。所以不需要初始化
    28. }
    29. ########################
    30. 控制台输出：
    31. 1
    1. public class T { //T:使用系统类加载器加载。
    2.  public static int k = 0;
    3.  public static T t1 = new T("t1");
    4.  public static T t2 = new T("t2");
    5.  public static int i = print("i");
    6.  public static int n = 99;
    8.  static {
    9.      print("静态块");
    10.  }
    12.  public int j = print("j");
    14.  {
    15.      print("构造块");
    16.  }
    18.  public T(String str) {
    19.      System.out.println((++k) + ":" + str + "  i=" + i + "  n=" + n);
    20.      ++n;
    21.      ++i;
    22.  }
    24.  public static int print(String str) {
    25.      System.out.println((++k) + ":" + str + "  i=" + i + "  n=" + n);
    26.      ++n;
    27.      return ++i;
    28.  }
    30.  public static void main(String[] args) {
    31.      String str = "info";  //String:使用引导类加载器加载
    32.  }
    33. }