jvm和类

当调用 Java 命令运行某个 Java 程序时，该命令将会启动一个 Java 虚拟机进程，不管该 Java 程序有多么复杂，该程序启动了多少个线程，它们都处于该 Java 虚拟机进程里 。
在同一个jvm的所有线程，所有变量都处于同一个进程里，它们使用jvm的内存区。不同的jvm内存区信息不共享。
jvm进程终止的几种原因：

1、程序运行到最后正常结束。
2、程序运行到System.exit()或Runtime.getRuntime().exit()代码区结束。
3、程序运行过程中遇到未捕获的异常或者错误而退出。
4、程序所在的平台强制结束了jvm的进程（命令行或者任务管理器强制杀死该进程）
1
2
3
4

两个jvm的运行是独立的，数据不互通

在java虚拟机中，运行两个不同的类，所运行的过程是独立的，它们的数据不互通。
实例代码：

public class B{
    static int a = 6;
    public B(){
        a++;
    }
}
1
2
3
4
5
6

public class ATest {
    public static void main(String[] args) {
        B.a++;
        System.out.println(B.a);
    }
}
1
2
3
4
5
6

public class BTest {
    public static void main(String[] args) {
        B b = new B();
        B.a++;
        System.out.println(b.a);
    }
 }
1
2
3
4
5
6
7

代码分析：
ATest的输出是7，BTest的输出是8，ATest调用B.a++后没有在B类里面运行B类的构造函数，直接是静态域的a自加为7，BTest的输出是8，而不是9的原因是main函数里面的第一行代码创建了一个B的对象，创建的过程中默认调用了B的无参数构造器，所以a的值从6变成7，在main函数里面的第二行代码，再次引用了B类里面的变量自加，从7变成8。所以两个jvm的运行过程是独立的，数据不互通。

类的使用

java程序对类的使用分主动使用和被动使用。

主动使用

主动使用分为以下几种情况：

1、创建类的实例
2、访问某一个类或者接口的静态变量，或者对该静态变量赋值。
3、调用类的静态方法
4、反射（比如Class.forName(“com.temp.Test01”)）
5、初始化一个类的子类
6、java虚拟机启动时被标明是启动类的类时。
7、JDK7开始提供的动态语言支持，java.lang.invoke.MethodHandle实例的解析结果。REF_getStatic、REF_putStatic、REF_invokeStatic句柄对应的类没有初始化，则初始化。

基本上除了以上七种情况，其他使用java类的方式都被看作类的被动使用，都不会导致类的初始化。

被动使用

实例代码1：

public class SuperClass {
    static {
        System.out.println("SuperClass init!");
    }
    public static int value = 123;
}
1
2
3
4
5
6

public class SubClass extends SuperClass {
    static {
        System.out.println("SubClass init!");
    }
}
1
2
3
4
5

// 通过子类引用父类的静态字段，不会导致子类初始化
public class NotInitialization {
    public static void main(String[] args) {
        System.out.println(SubClass.value);
    }
}
1
2
3
4
5
6

代码分析： 上述代码运行之后，只会输出“SuperClass init！ ”，而不会输出“SubClass init！ ”。对于静态字段，只有直接定义这个字段的类才会被初始化，因此通过其子类来引用父类中定义的静态字段，只会触发父类的初始化而不会触发子类的初始化。

package GenericsTest.JVMTest.Test816;
/**
* 通过数组定义来引用类，不会触发此类的初始化
**/
public class NotInitialization {
    public static void main(String[] args) {
        SuperClass[] sca = new SuperClass[10];
    }
}

1
2
3
4
5
6
7
8
9
10

运行之后发现没有输出“SuperClassinit！ ”，
说明并没有触发类GenericsTest.JVMTest.Test816.SuperClass的初始化阶段。

实例代码2：

public class ConstClass {
    static {
        System.out.println("ConstClass init!");
    }
    public static final String HELLOWORLD = "hello world";
}
1
2
3
4
5
6

public class NotInitialization {
    public static void main(String[] args) {
        System.out.println(ConstClass.HELLOWORLD);
    }
}
1
2
3
4
5

代码分析： 上述代码运行之后，也没有输出“ConstClass init！ ”，这是因为虽然在Java源码中确实引用了ConstClass类的常量HELLOWORLD，但其实在编译阶段通过常量传播优化，已经将此常量的值“hello world”直接存储在NotInitialization类的常量池中，以后NotInitialization类对常量ConstClass.HELLOWORLD的引用，实际都被转化为NotInitialization类对自身常量池的引用了。也就是说，实际上NotInitialization的Class文件之中并没有ConstClass类的符号引用入口，这两个类在编译成Class文件后就已不存在任何联系了。