每个线程:独立包括程序计数器、栈、本地栈
线程间共享:堆、堆外内存(永久代或元空间、代码缓存)
线程是一个程序里的运行单元。JVM允许一个应用有多个线程并行的执行
在Hotspot JVM里,每个线程都与操作系统的本地线程直接映射。个Java线程准备好执行以后,此时一个操作系统的本地线程也同时创建。Java线程执行终止后,本地线程也会回收。
操作系统负责所有线程的安排调度到任何一个可用的CPU上。一旦本地线程初始化成功,它就会调用Java线程中的run()方法

jvm线程

如果你使用 jconsole或者是任何一个调试工具,都能看到在后台有许多线程在运行。这些后台线程不包括调用 public static void main( string[]args)的main线程以及所有这个maih线程自己创建的线程。这些主要的后台系统线程在 Hotspot J里主要是以下几个：

虚拟机线程:这种线程的操作是需要达到安全点才会出现。这些操作必须在不同的线程中发生的原因是他们都需要JVM达到安全点,这样堆才不会变化。这种线程的执行类型包括〃stop-the-world"的垃圾收集,线程栈收集,线程挂起以及偏向锁撤销。
周期任务线程:这种线程是时间周期事件的体现(比如中断),他们一般用于周期性操作的调度执行。
GC线程:这种线程对在JVM里不同种类的垃圾收集行为提供了支持。
编译线程:这种线程在运行时会将字节码编译成到本地代码。
信号调度线程:这种线程接收信号并发送给jvm,在它内部通过调用适当的方法进行处理。

2.虚拟机栈

Java虚拟机栈是什么

Java虚拟机栈( Java virtual Machine stack),早期也叫Java栈。每个线程在创建时都会创建一个虚拟机栈,其内部保存一个个的栈帧( Stack frame),对应着一次次的Java方法调用。
是线程私有的

每个栈帧中存储着:

局部变量表(Local Variab1es)
操作数栈( Operand stack)(或表达式栈)
动态链接( Dynamic Linking)(或指向运行时常量池的方法引用)
方法返回地址( Return address)(或方法正常退出或者异常退出的定义)
一些附加信息

生命周期

生命周期和线程一致。

作用

主管Java程序的运行,它保存方法的局部变量、部分结果,并参与方法的调用和返回。

说明

栈是运行时的单位,而堆是存储的单位。

栈的特点(优点)

栈是一种快速有效的分配存储方式,访问速度仅次于程序计数器。
JVM直接对Java栈的操作只有两个：1.每个方法执行,伴随着进栈(入栈、压栈)，2.执行结束后的出栈工作
对于栈来说不存在垃圾回收问题

栈可能出现的异常

如果釆用固定大小的Java虚拟机栈,那每一个线程的Java虚拟机栈容量可以在线程创建的时候独立选定。如果线程请求分配的栈容量超过Java虚拟机栈允许的最大容量,Java虚拟机将会抛出一个StackOverFlowError异常。
如果Java虚拟机栈可以动态扩展,并且在尝试扩展的时候无法中请到足够的内存,或者在创建新的线程时没有足够的内存去创建对应的虚拟机栈,那Java虚拟机将会抛出一个 OutOfMemoryError异常。
使用参数-Xss选项来设置线程的最大栈空间,栈的大小直接决定了函数调用的最大可达深度。

举例：

public class Test1 {
    static int i=0;
    public static void main(String[] args) {
        test();
    }
    public static void test(){
        System.out.println(++i);
        test();
    }
}

JVM参数：

-Xss512K -XX:+PrintFlagsFinal

执行了5074次

-Xss修改为256K 执行了2331次

栈运行原理

不同线程中所包含的栈是不允许存在相互引用的,即不可能在一个栈帧之中引用另外一个线程的栈帧。
如果当前方法调用了其他方法,方法返回之际,当前栈帧会传回此方法的执行结果给前一个栈帧,接着,虚拟机会丢弃当前栈帧,使得前一个栈帧重新成为当前栈帧。
Java方法有两种返回函数的方式,一种是正常的函数返回,使用 return指令;另外一种是抛岀异常。不管使用哪种方式,都会导致栈帧被弹出。

1.局部变量表

局部变量表也被称之为局部变量数组或本地变量表
定义为一个数字数组,主要用于存储方法参数和定义在方法体内的局部变量，这些数据类型包括各类基本数据类型、对象引用( reference),以及returnAddress类型。
由于局部变量表是建立在线程的栈上,是线程的私有数据,因此不存在数据安全问题
局部变量表所需的容量大小是在编译期确定下来的,并保存在方法的code属性的 maximum local variables数据项中。在方法运行期间是不会改变局部变量表的大小的
方法嵌套调用的次数由栈的大小决定。一般来说,栈越大,方法嵌套调用次数越多。对一个函数而言,它的参数和局部变量越多,使得局部变量表膨胀,它的栈帧就越大,以满足方法调用所需传递的信息增大的需求。进而函数调用就会占用更多的栈空间,导致其嵌套调用次数就会减少。
局部变量表中的变量只在当前方法调用中有效。在方法执行时,虚拟机通过使用局部变量表完成参数值到参数变量列表的传递过程。当方法调用结束后,随着方法栈帧的销毁,局部变量表也会随之销毁。

补充说明：

在栈帧中,与性能调优关系最为密切的部分就是前面提到的局部变量表。在方法执行时,虚拟机使用局部变量表完成方法的传递。
局部变量表中的变量也是重要的垃圾回收根节点,只要被局部变量表中直接或间接引用的对象都不会被回收。

slot变量槽

局部变量表,最基本的存储单元是slot

byte、 short、char在存储前被转换为int, boolean也被转换为int,0表示false,非0表示true。
long和 double则占据两个solt

请看下面的示例使用jclasslib插件查看，序号0为this，序号1 double占两个 3开始是long

public class Test3 {
    public void localvarl() {
        double c=0;
        long f=0;
        byte a=0;
        int b=0;
        boolean d=false;
        float e=0f;
        char g=0;
    }
}

slot重复利用

public class Test3 {
    public void localvarl() {
        int a = 0;
        System.out.println(a);
        int b = 0;
    }
    public void localvarl1() {
        {
            int a = 0;
            System.out.println(a);
        }
        int b = 0;
    }
}

2.操作数栈

每一个独立的栈帧中除了包含局部变量表以外,还包含一个后进先出(Last-In- First-0ut)的操作数栈,也可以称之为表达式栈( Expression Stack)。

操作数栈,主要用于保存计算过程的中间结果,同时作为计算过程中变量临时的存储空间。

操作数栈就是JVM执行引擎的一个工作区,当一个方法刚开始执行的时候,一个新的栈帧也会随之被创建出来,这个方法的操作数栈是空的。

每一个操作数栈都会拥有一个明确的栈深度用于存储数值,其所需的最大深度在编译期就定义好了

操作数栈,在方法执行过程中,根据字节码指令,往栈中写入数据或提取数据,即入栈(push)/出栈(pop)。

某些字节码指令将值压入操作数栈,其余的字节码指令将操作数出栈。使用它们后再把结果压入栈
比如:执行复制、交换、求和等操作

举例：

iconst_1读取（入栈）pc寄存器0 ，istore_1(出栈)放到局部变量表 pc寄存器1
iconst_2读取（入栈）pc寄存器2 ，istore_2(出栈)放到局部变量表 pc寄存器3
iload_1 pc寄存器4、iload_2 pc寄存器5读取局部变量表 1,2的值
iadd pc寄存器6 出栈计算结果放回操作数栈
istore_3 pc寄存器7将结果出栈存储到局部变量表

public class Test4 {
    public void test4(){
        int i=1;
        int j=2;
        int c=i+j;
    }
}

栈顶缓存技术

由于操作数是存储在内存中的,因此频繁地执行内存读/写操作必然会影响执行速度。为了解决这个问题, Hotspot JVM的设计者们提出了栈顶缓存(ToS,Top-of- Stack Cashing)技术,将栈顶元素全部缓存在物理CPU的寄存器中,以此降低对内存的读/写次数,提升执行引擎的执行效率。

3.动态链接

每一个栈帧内部都包含一个指向运行时常量池中该栈帧所属方法的引用包含这个引用的目的就是为了支持当前方法的代码能够实现动态链接( Dynamic Linking)。比如: invokedynamic指令在Java源文件被编译到字节码文件中时,所有的变量和方法引用都作为符号引用( Symbolic Reference)保存在 class文件的常量池里。比如:描述一个方法调用了另外的其他方法时,就是通过常量池中指向方法的符号引用来表示的,那么动态链接的作用就是为了将这些符号引用转换为调用方法的直接引用。

4.方法返回地址

方法退出后都返回到该方法被调用的位置,存放调用该方法的pc寄存器的值。

一个方法的结束,有两种方式:

正常执行完成：调用该方法的指令的下一条指令的地址
非正常退出(异常)：返回地址是要通过异常表来确定,栈帧中一般不会保存这部分信息

5.一些附加信息

栈帧中还允许携带与Java虚拟机实现相关的一些附加信息。例如,对程序调试提供支持的信息。

3.程序计数器

它是一块很小的内存空间,几乎可以忽略不记。也是运行速度最快的存储区域。
在JVM规范中,每个线程都有它自己的程序计数器,是线程私有的,生命周期与线程的生命周期保持一致。
任何时间一个线程都只有一个方法在执行,也就是所谓的当前方法。程序计数器会存储当前线程正在执行的Java方法的JVM指令地址;或者,如果是在执行 native方法,则是未指定值( undefned)。
它是程序控制流的指示器,分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。
字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令。
它是唯一一个在Java虚拟机规范中没有规定任何 OutOtMemoryError情况的区域。

作用：PC寄存器用来存储指向下一条指令的地址也即将要执行的指令代码。由执行引擎读取下一条指令

CPU时间片

CPU时间片即CPU分配给各个程序的时间,每个线程被分配一个时间段,称作它的时间片

在宏观上:我们可以同时打开多个应用程序,每个程序并行不悖,同时运行。

在微观上:由于只有一个CPU,一次只能处理程序要求的一部分如何处理公平,一种方法就是引入时间片,每个程序轮流执行。

常见问题：

PC寄存器为什么会被设定为线程私有?

我们都知道所谓的多线程在一个特定的时间段内只会执行其中某一个线程的方法,CPU会不停地做任务切换,这样必然导致经常中断或恢复,如何保证分毫无差呢?为了能够准确地记录各个线程正在执行的当前字节码指令地址,最好的办法自然是为每一个线程都分配一个PC寄存器,这样一来各个线程之间便可以进行独立计算,从而不会出现相互干扰的情况。
由于CPU时间片轮限制,众多线程在并发执行过程中,任何一个确定的时刻,一个处理器或者多核处理器中的一个内核,只会执行某个线程中的一条指令。
这样必然导致经常中断或恢复,如何保证分毫无差呢?每个线程在创建后,都会产生自己的程序计数器和栈帧,程序计数器在各个线程之间互不影响。

举例：

4.本地方法栈

本地方法接口

简单地讲,一个 Native Method就是一个Java调用非Java代码的接口。一个Native method是这样一个Java方法:该方法的实现由非Java语言实现,比如C。

本地方法栈

本地方法栈用于管理本地方法的调用。是线程私有的

如果线程请求分配的栈容量超过本地方法栈允许的最大容量,Java虚拟机将会抛出一个 StackOverflowError异常。

如果本地方法栈可以动态扩展,并且在尝试扩展的时候无法申请到足够的内存,或者在创建新的线程时没有足够的内存去创建对应的本地方法栈,那么Java虚拟机将会抛出一个 outofmemoryerror异常。

5.堆

定义

一个JVM实例只存在一个堆内存,堆也是Java内存管理的核心区域。
《Java虚拟机规范》中对Java堆的描述是:所有的对象实例以及数组都应在运行时分配在堆上。
数组和对象可能永远不会存储在栈上,因为栈帧中保存引用,这个引用指向对象或者数组在堆中的位置。
在方法结束后,堆中的对象不会马上被移除,仅仅在垃圾收集的时候才会被移除.
堆,是GC( Garbage Collection,垃圾收集器)执行垃圾回收的重点区域。

对象分配

针对不同年龄段的对象分配原则如下所示:

优先分配到Eden
如果对象在Eden出生并经过第一次 Minor GC后仍然存活,并且能被 Survivor容纳的话,将被移动到 Survivor空间中,并将对象年龄设为1。对象在Survivor区中每熬过一次 Minor GC,年龄就增加1岁,当它的年龄增加到一定程度(默认为15岁,其实每个JVM、每个GC都有所不同)时,就会被晋升到老年代中
大对象直接分配到老年代,尽量避免程序中出现过多的大对象
长期存活的对象分配到老年代
动态对象年龄判断如果 Survivor区中相同年龄的所有对象大小的总和大于 Survivor空间的一半,年龄大于或等于该年龄的对象可以直接进入老年代,无须等到MaxtenuringThreshold中要求的年龄

示例：

借助jvisualvm 的visual gc可以看到 eden、s0、s1、old区的分配情况，通过修改byte[]数组大小可以让其分配不同方式，可能进入eden区，可能直接进入old区

public class Test6 {
    byte[] buffer = new byte[1024 * 1024*1];

    public static void main(String[] args) {
        ArrayList<Test6> list = new ArrayList<>();
        while (true){
            list.add(new Test6());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}

设置参数

官网地址：https://docs.oracle.com/javase/8/docs/technotes/tools/unix/java.html

默认-XX: NewRatio=2,表示新生代占1,老年代占2,新生代占整个堆的1/3
可以修改-XX: NewRatio=4,表示新生代占1,老年代占4,新生代占整个堆的1/5
Eden空间和 Survivor空间缺省所占的比例是8:1:1 可以通过“-XX: SurvivorRatio”调整这个空间比例。比如-x: Survivorratio=8

空间担保

在发生Minor GC之前，虚拟机会检查老年代最大可用的连续空间是否大于新生代所有对象的总空间，如果大于，则此次Minor GC是安全的，如果小于，则虚拟机会查看HandlePromotionFailure设置值是否允许担保失败。如果HandlePromotionFailure=true，那么会继续检查老年代最大可用连续空间是否大于历次晋升到老年代的对象的平均大小，如果大于，则尝试进行一次Minor GC，但这次Minor GC依然是有风险的；如果小于或者HandlePromotionFailure=false，则改为进行一次Full GC。

TLAB

为什么有TLAB

堆区是线程共享区域,任何线程都可以访问到堆区中的共享数据
由于对象实例的创建在JVM中非常频繁,因此在并发环境下从堆区中划分内存空间是线程不安全的
为避免多个线程操作同一地址,需要使用加锁等机制,进而影响分配速度。

定义

从内存模型而不是垃圾收集的角度,对Eden区域继续进行划分,JVM为每个线程分配了一个私有缓存区域,它包含在Eden空间内
多线程同时分配内存时,使用TLAB可以避免一系列的非线程安全问题,同时还能够提升内存分配的吞吐量,称为快速分配策略。
一旦对象在TLAB空间分配内存失败时,JVM就会尝试着通过使用加锁机制确保数据操作的原子性,从而直接在Eden空间中分配内存。
在程序中,开发人员可以通过选项“-XX: UseTLAB”设置是否开启TLAB空间。
默认情况下,TLAB空间的内存非常小,仅占有整个Eden空间的1%,当然我们可以通过选项“-XX: TLABWasteTargetPercent”设置TLAB空间所占用Eden空间的百分比大小。

GC

        JVM在进行GC时,并非每次都对上面三个内存(新生代、老年代;方法区)区域一起回收的,大部分时候回收的都是指新生代。
        针对 Hotspot VN的实现,GC按照回收区域又分为两大种类型:一种是部分收集( PartialGC),一种是整堆收集(Full GC)
       部分收集:不是完整收集整个]ava堆的垃圾收集。其中又分为:

新生代收集( Minor GC/ Young GC):只是新生代的垃圾收集
老年代收集( Major GC/ old GC):只是老年代的垃圾收集。目前,只有 CMS GC会有单独收集老年代的行为。ˇ注意,很多时候 Major GC会和Full GC混淆使用,需要具体分辨是老年代回收还是整堆回收。
混合收集( Mixed GC):收集整个新生代以及部分老年代的垃圾收集，目前,只有G1GC会有这种行为
整堆收集(Full GC):收集整个java堆和方法区的垃圾收集。

年轻代GC( Minor GC)触发机制:

当年轻代空间不足时,就会触发 Minor GC,这里的年轻代满指的是Eden代满, Survivor满不会引发GC。(每次 Minor Gc会清理年轻代的内存。)
因为Java对象大多都具备朝生夕灭的特性,所以 Minor gc非常频繁,一般回收速度也比较快。这一定义既清晰又易于理解
Minor gc会引发STW,暂停其它用户的线程,等垃圾回收结束,用户线程才恢复运行

老年代GC( Major GC/FullGC)触发机制:

指发生在老年代的GC,对象从老年代消失时,我们说“ Major GC”或“Fu11GC发生了。
出现了 Major GC,经常会伴随至少一次的 Minor GC(但非绝对的,在Parallel Scavenge收集器的收集策略里就有直接进行 Major GC的策略选择过程)
也就是在老年代空间不足时,会先尝试触发 Minor GC。如果之后空间还不足,则触发 Major GC
Major GC的速度一般会比 Minor gc慢10倍以上,STW的时间更长。

触发FullGc执行的情况有如下五种:

(1)调用 System. gc()时,系统建议执行Fu11GC,但是不必然执行
(2)老年代空间不足
(3)方法区空间不足
(4)通过 Minor GC后进入老年代的平均大小大于老年代的可用内存
(5)由Eden区、 from区向 from区复制时,对象大小大于 To Space可用内存,则把该对象转存到老年代,且老年代的可用内存小于该对象大小

说明:full gc是开发或调优中尽量要避免的。这样暂时时间会短一些。

为什么需要把Java堆分代?
不分代就不能正常工作了吗?其实不分代完全可以,分代的唯一理由就是优化GC性能。如果没有分代,那所有的对象都在一块,就如同把一个学校的人都关在一个教室。GC的时候要找到哪些对象没用,这样就会对堆的所有区域进行扫描。而很多对象都是朝生夕死的,如果分代的话,把新创建的对象放到某一地方,当GC的时候先把这块存储“朝生夕死”对象的区域进行回收,这样就会腾出很大的空间出来。

逃逸分析

逃逸分析的基本行为就是分析对象动态作用域:

当一个对象在方法中被定义后,对象只在方法内部使用,则认为没有发生逃逸。
当一个对象在方法中被定义后,它被外部方法所引用,则认为发生逃逸。例如作为调用参数传递到其他地方中。

优化

同步省略（消除）。如果一个对象被发现只能从一个线程被访问到,那么对于这个对象的操作可以不考虑同步。
栈上分配。将堆分配转化为栈分配。如果一个对象在子程序中被分配,要使指向该对象的指针永远不会逃逸,对象可能是栈分配的候选,而不是堆分配，配合标量替换
分离对象或标量替换。有的对象可能不需要作为一个连续的内存结构存在也可以被访问到,那么对象的部分(或全部)可以不存储在内存,而是存储在CPU寄存器中。如图：

逃逸分析一定快吗？

无法保证逃逸分析的性能消耗一定能高于他的消耗。虽然经过逃逸分析可以做标量替换、栈上分配、和锁消除。但是逃逸分析自身也是需要进行一系列复杂的分析的,这其实也是一个相对耗时的过程。
一个极端的例子,就是经过逃逸分析之后,发现没有一个对象是不逃逸的。那这个逃逸分析的过程就白白浪费掉了。

6.方法区

存储已被虚拟机加载的类型信息、运行时常量池、静态变量、JIT代码缓存、域(field)信息、方法信息等

元空间和永久代最大区别：元空间不在虚拟机设置的内存中，而是使用本地内存

字符串常量池

字符串常量池中是不会存储相同容的字符串的。常量池是一个固定大小的 Hashtable,默认值大小长度是1009。如果放进 string非常多,就会造成Hash冲突严重，性能下降，jdk8常量池在堆中

string类型的常量池比较特殊。它的主要使用方法有两种。

直接使用双引号声明出来的 string对象会直接存储在常量池中，比如:String info="com";
可以使用 string提供的intern()方法。

字符串拼接

常量与常量的拼接结果在常量池,原理是编译期优化
常量池中不会存在相同内容的常量。
只要其中有一个是变量,结果就在堆中。变量拼接的原理是 Stringbuilder
如果拼接的结果调用 intern()方法,则主动将常量池中还没有的字符串对象放入池中,并返回此对象地址。

public class Test7 {
    public static void main(String[] args) {
        test7();
    }
    public static void test7() {
        String a="a"+"b"+"c";
        String b="d";
        String c=b+"e";

    }
}

intern使用

public class Test8 {
    public static void main(String[] args) {
        test8();
//        test8_1();
    }
    public static void test8() {
        String a=new String("a");
        String intern = a.intern();
        String a1="a";
        System.out.println(a==intern);//false
        System.out.println(a==a1);//false
        System.out.println(a1==intern);//true
    }

    public static void test8_1() {
        String a=new String("a")+new String("b");
        String intern = a.intern();
        String a1="ab";
        System.out.println(a==intern);//true
        System.out.println(a==a1);//true
        System.out.println(a1==intern);//true
    }
}

7.执行引擎

解释器:当Java虚拟机启动时会根据预定义的规范对字节码采用逐行解释的方式执行,将每条字节码文件中的内容“翻译”为对应平台的本地机器指令执行。

JIT编译器:就是虚拟机将源代码直接编译成和本地机器平台相关的机器语言，在一定周期内代码被调用执行频率而定，热点代码会做jit编译进行优化

现在JVM在执行Java代码的时候,通常都会将解释执行与编译执行二者结合起来进行。

原文链接：https://blog.csdn.net/three_stand/article/details/122543232