深入JVM虚拟机(二) JVM运行机制

1 JVM运行机制

1.1 JVM启动流程

JVM是Java程序运行的环境，同时是一个操作系统的一个应用程序进程，因此它有自己的生命周期，也有自己的代码和数据空间。JVM工作原理和特点主要是指操作系统装入JVM，是通过jdk中Java.exe来完成通过下面4步来完成JVM环境。

1、创建JVM装载环境和配置。

2、装载JVM.dll。

3、初始化JVM.dll并挂界到JNIENV(JNI调用接口)实例。

4、调用JNIEnv实例装载并处理class类。

JVM启动流程图1-1

1.2 JVM基本结构

JVM中的内存主要划分为：方法区，Java堆区，Java虚拟机栈，本地方法栈，程序计数器栈五个部分，如下图：

JVM基本结构图1-2

1、方法区：

也叫”永久代”,用于存储已经加载的类信息，常量，静态变量以及方法代码。方法区内存大小默认最小值为16MB，最大值为64MB。

2、Java堆：

线程共享的，存放所有对象实例和数组。垃圾回收的主要区域。可以分为新生代和老年代(tenured)。

新生代用于存放刚创建的对象以及年轻的对象，如果对象一直没有被回收，生存得足够长，老年对象就会被移入老年代。

新生代又可进一步细分为eden、survivorSpace0(s0,fromspace)、survivorSpace1(s1,tospace)。刚创建的对象都放入eden,s0和s1都至少经过一次GC并幸存。如果幸存对象经过一定时间仍存在，则进入老年代(tenured)。。

3、Java栈：

栈由一系列帧组成（因此Java栈也叫做帧栈），栈帧是后进先出的栈式结构，栈帧中存放方法运行时的局部变量、方法出口等信息。当调用一个方法时，就会在虚拟机栈中创建一个栈帧用于存放这些数据，方法调用完时栈帧消失。若方法中又调用了其他方法，则继续在栈顶创建新的栈。

4、本地方法栈：

与虚拟机栈类似，区别是本地方法栈是为Native方法服务的，而java虚拟机栈是为java方法服务的。

5、指令计数器：

多线程时，当线程数超过CPU数量或CPU内核数量，线程之间就要根据时间片轮询抢夺CPU时间资源。因此每个线程有要有一个独立的程序计数器，记录下一条要运行的指令。线程私有的内存区域。如果执行的是JAVA方法，计数器记录正在执行的java字节码地址，如果执行的是native方法，则计数器为空。

寄存器是最快的存储区，因为它位于不同于其他存储区的地方——处理器内部。但是寄存器的数量极其有限，所以寄存器根据需求进行分配。

6、垃圾收集器：

JVM分别对新生代和旧生代采用不同的垃圾回收机制。

7、执行引擎：

JVM通过执行引擎来完成字节码的执行，在执行过程中JVM采用的是自己的一套指令系统，每个线程在创建后，都会产生一个程序计数器（pc）和栈（Stack）。

1.3 Java栈

1、Java栈局部变量表：

    public class StackDemo {
        public static int runStatic(int i, long l, float f, Object o, byte b) {
            return 0;
        }
        public int runInstance(char c, short s, boolean b) {
            return 0;
        }
    }

静态方法runStatic()栈： 实例方法runInstance()栈：

2、函数调用组成帧栈：

	public static int runStatic(int i, long l, float f, Object o, byte b) {
		return runStatic(i, l, f, o, b);
	}

    runStatic()递归调用，每次调用都创建一个帧压到栈里面，直到栈帧溢出。方法调用结束后会自动移除。

…

3、操作数栈

Java没有寄存器，所有参数传递使用操作数栈。

JAVA代码：

        public static int add(int a, int b) {
            int c = 0;
            c = a + b;
            return c;
        }

0:  iconst_0 // 0压栈

1:  istore_2 //弹出int，存放于局部变量2

2:  iload_0  //把局部变量0压栈

3:  iload_1 //局部变量1压栈

4:  iadd      //弹出2个变量，求和，结果压栈

5:  istore_2 //弹出结果，放于局部变量2

6:  iload_2  //局部变量2压栈

7:  ireturn   //返回

4、栈上分配

-  栈上一般都是分配的小对象（一般几十个bytes），并且在没有逃逸的情况下（逃逸：没有在别的地方进行引用）。

-  直接分配在栈上，可以自动回收，减轻GC压力。

-  大对象或者逃逸对象无法栈上分配。

1.4 栈、堆、方法区交互

栈、堆、方法区交互图1-1

Java代码：

	// 运行时, jvm 把appmain的信息都放入方法区 
	public class AppMain {
		// main 方法本身放入方法区
		public static void main(String[] args) {
			// test1是引用，所以放到栈区里， Sample是自定义对象应该放到堆里面 
			Sample test1 = new Sample("测试1");
			Sample test2 = new Sample("测试2");
			test1.printName();
			test2.printName();
		}
	}

	public class Sample {
		private String name;
	
		// new Sample实例后， name 引用放入栈区里，name 对象放入堆里 
		public Sample(String name) {
			this.name = name;
		}
	
		// print方法本身放入 方法区里
		public void printName() {
			System.out.println(name);
		}
	}

1.5 内存模型

1、内存模型：

-  每一个线程有一个工作内存和主存独立。

-  工作内存放主存中变量的值的拷贝。

内存模型图1-1

-  当数据从主内存复制到工作存储时，必须出现两个动作：第一，由主内存执行的读（read）操作；第二，由工作内存执行的相应的load操作；当数据从工作内存拷贝到主内存时，也出现两个操作：第一个，由工作内存执行的存储（store）操作；第二，由主内存执行的相应的写（write）操作

-  每一个操作都是原子的，即执行期间不会被中断。

-  对于普通变量，一个线程中更新的值，不能马上反应在其他变量中，如果需要在其他线程中立即可见，需要使用 volatile关键字

内存模型图1-2

2、volatile关键字

Java语言提供了一种稍弱的同步机制，即 volatile变量.用来确保将变量的更新操作通知到其他线程，保证了新值能立即同步到主内存，以及每次使用前立即从主内存刷新。当把变量声明为volatile类型后，编译器与运行时都会注意到这个变量是共享的。

JAVA代码：

	public class VolatileStopThread extends Thread {
		private volatile boolean stop = false;
		// private boolean stop = false;
	
		public void stopMe() {
			stop = true;
		}
	
		public void run() {
			int i = 0;
			while (!stop) {
				i++;
				System.out.println("i=" + i);
			}
			System.out.println("Stop thread");
		}
	
		public static void main(String args[]) throws InterruptedException {
			VolatileStopThread t = new VolatileStopThread();
			t.start();
			Thread.sleep(1000);
			t.stopMe();
			Thread.sleep(1000);
		}
	}

看了上面的代码 stop变量没有加，我们期待的是线程一直在执行，一直在while条件里面循环i++，实际执行结果：

i=145411

i=145412

Stop thread

分析原因：内存区域是jvm虚拟机栈，每一个线程运行时都有一个线程栈，线程栈保存了线程运行时候变量值信息。当线程访问某一个对象时候值的时候，首先通过对象的引用找到对应在堆内存的变量的值，然后把堆内存变量的具体值load到线程本地内存中，建立一个变量副本，之后线程就不再和对象在堆内存变量值有任何关系，而是直接修改副本变量的值，在修改完之后的某一个时刻（线程退出之前），自动把线程变量副本的值回写到对象在堆中变量。这样在堆中的对象的值就产生变化了。

3、可见性

一个线程修改了变量，其他线程可以立即知道，保证可见性的方法：

volatile

synchronized（unlock之前，写变量值回主存）

final(一旦初始化完成，其他线程就可见)

4、有序性

-  在本线程内，操作都是有序的

-  在线程多线程情况下观察，操作都是无序的。无序有两种情况：

1：指令重排。

2：主内存同步延迟。

1.6 指令重排

1、指令重排：

-  线程内串行语义：

不可重排语句:

写后读 a = 1;b = a;写一个变量之后，再读这个位置。

写后写 a = 1;a = 2;写一个变量之后，再写这个变量。

读后写 a = b;b = 1;读一个变量之后，再写这个变量。

-  编译器不考虑多线程间的语义

-  可重排： a=1;b=2

2、指令重排–破坏线程间的有序性

JAVA代码：

	public class OrderExample {
		int a = 0;
		boolean flag = false;
	
		public void writer() {
			a = 1;
			flag = true;
		}
	
		public void reader() {
			if (flag) {
				int i = a + 1;
			}
		}
	}

     线程A首先执行writer()方法

线程B线程接着执行reader()方法

线程B在int i=a+1 是不一定能看到a已经被赋值为1，因为在writer中，两句话顺序可能打乱

线程A：flag=true a=1

线程B：flag=true(此时a=0)

3、指令重排–保证有序性的方法

	public class OrderExample {
		int a = 0;
		boolean flag = false;
	
		public synchronized void writer() {
			a = 1;
			flag = true;
		}
	
		public synchronized void reader() {
			if (flag) {
				int i = a + 1;
			}
		}
	}

同步后，即使做了writer重排，因为互斥的缘故，reader线程看writer线程也是顺序执行的。

线程A：flag=true a=1

线程B：flag=true(此时a=1)

4、指令重排的基本原则

-  程序顺序原则：一个线程内保证语义的串行性

-  volatile规则：volatile变量的写，先发生于读

-  锁规则：解锁(unlock)必然发生在随后的加锁(lock)前

-  传递性：A先于B，B先于C那么A必然先于C

-  线程的start方法先于它的每一个动作

-  线程的所有操作先于线程的终结（Thread.join()）

-  线程的中断（interrupt()）先于被中断线程的代码

-  对象的构造函数执行结束先于finalize()方法

1.7 字节码运行方式

1、解释运行

-  解释执行以解释方式运行字节码

-  解释执行的意思是：读一句执行一句

2、编译运行（JIT）

-  将字节码编译成机器码

-  直接执行机器码

-  运行时编译

-  编译后性能有数量级的提升

                                                                                                                                                                                      ——厚积薄发(yuanxw)