Java：104-JVM优化

已于 2024-06-23 17:46:47 修改

分类专栏：笔记文章标签： jvm优化 java

于 2023-02-25 20:40:41 首次发布

115 篇文章 9 订阅

package com.test1;

/**
 *
 */
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

0 getstatic #2 <java/lang/System.out>  // getstatic 获取静态字段的值  
3 ldc #3 <Hello World>                 // ldc 常量池中的常量值入栈
5 invokevirtual #4 <java/io/PrintStream.println>   // invokevirtual 运行时方法绑定调用方法 
8 return    //void 函数返回

//可以找到如下：
Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #3                  // String Hello World
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
//注意：可能你运行一次并不会出现这些，等下再次的运行即可（因为可能他并没有加载好，或者需要初始化，或者有问题）

package com.test1;

/**
 *
 */
public class PC {
    public static void main(String[] args) {
        int x = 1;
        int y = 2;
        System.out.println(x+y);
    }
}

指令地址 操作指令 
0       iconst_1   //数值 1，相当于1
1       istore_1   //存储1（x），即就是int x = 1，很明显，上面操作了iconst_1（执行），那么这里操作存储（存储他，他们都是分开执行的，而不是代码中（源码中）的有联系的），自然就是操作该1，即x（前缀一般代表执行，后缀一般代表具体变量，_分开的，即1给x了），即istore的1不是具体数字，而是对应变量的编号，或者说他整个就是一个编号，只是他的名称会附带赋值操作而已，通常代表第几个变量，1代表第一个就是x（一般不会与栈有关，因为pc寄存器是先操作使得执行的，而虚拟机栈后操作，那么则是解释的问题，即与其他字节码相关，虽然其他的大致忽略，这里了解即可）
2       iconst_2   //同理相当于y
3       istore_2   //存储2（y），即int x = 2，注意，对应的名称是可变的，也就是说iconst_1代表对应的数值是可以改变，自己修改就知道了，比如将1变成3，那么iconst_1就是iconst_3，当然，对应的istore_1一般是固定的，因为是按照顺序来的，在字节码（main对应里面的其他信息）后面可能会给出对应的顺序（数据）（自己可以通过javap查看，通常是局部变量表的序号），所以他是1，而iconst_3中3是没有保存的，所以他会变化来进行对应
4       getstatic #2 <java/lang/System.out : Ljava/io/PrintStream;> //开始获取值，获取的是他out的值
7       iload_1 //进行加载x（指定了1，那么在1这个位置，在字节码后面1这个位置就是x，他是保存的，而不是像数值一样的没有保存）
8       iload_2 //进行加载y
9       iadd //操作相加
10      invokevirtual #3 <java/io/PrintStream.println : (I)V> //运行该方法，当然，在编译期间自然会检查，加载的变量是否符合该方法的参数类型，这也是保存的原因（上面得到的结果，方法会操作获取的，相当于istore_1获取iconst_1一样，这是因为方法有参数，很明显正是因为编译符合，所以他方法执行才会合理，而不会出现没有参数前面也进行加载或者操作出现值的情况，即不会出现iadd或者iconst_1等等），但一般编译期间会检查出来的，虽然这里是运行期间，那么很明显，对应的获取out的值，他只是获取（进行考虑操作方法），而执行方法会利用加载的值，且是在获取的值上进行的（一般class到jvm就是运行期间，而java到class就是编译期间了（在注解中（第17章博客的RetentionPolicy.SOURCE这个），有只在java这里，即什么期间都没有的说明））
13      return //将结果返回
    
    //其中0到13我们称为指令地址，那么后面的自然就是操作指令了
    
    //之前的
0 getstatic #2 <java/lang/System.out>  // getstatic 获取静态字段的值  
3 ldc #3 <Hello World>                 // ldc 常量池中的常量值入栈
5 invokevirtual #4 <java/io/PrintStream.println>   // invokevirtual 运行时方法绑定调用方法 
8 return    //void 函数返回
    
    //上面为什么没有5或者6呢，一般代表是固定的数（地址），所以不能被占用，所以进行跳过，这里了解即可
    
      //实际上我们可以看到，看起来赋值是从左到右的，实际上代码整体是从左到右，从上到下，从里到外的，但有些不是都满足，如赋值就是不满足从左到右，而是从右到左，当然，在拿取数据时，如x+1，还是从左开始的
    //而在赋值时，之所以会出现从右到左是为了节省一些空间，而不是一直占用着（字节码层面）
    //从上面可以看出，实际上在并发情况下，就是因为这里的更加细节的处理，所以才会有并发的出现的，虽然我们大多数并没有这样说明

package com.test1;

/**
 *
 */
public class StackDemo {
    public static void main(String[] args) {
        StackDemo sd = new StackDemo();
        sd.A();
    }

    public void A() {
        int a = 10;
        System.out.println(" method A start");
        System.out.println(a);
        B();
        System.out.println("method A end");
    }

    public void B() {
        int b = 20;
        System.out.println(" method B start");
        C();
        System.out.println("method B end");
    }

    private void C() {
        int c = 30;
        System.out.println(" method C start");
        System.out.println("method C end");
    }

}

-Xss1m
-Xss1024k
-Xss1048576
#1024*1024=1048576
#所以后面表示的是b（8个字节：8bit）

package com.test1;

/**
 *
 */
public class StackTest {
    static long count = 0;
    public static void main(String[] args) {
        count++;
        System.out.println(count); //大概在85xx（xx代表浮动）左右就会溢出，但是有波动，也就是说，他虽然有上限，但是每次入栈的栈帧内存可能是忽上忽下的，完全平均很难（虽然也存在），因为需要考虑cpu的变化，以及内存的变化，一般有些是按照大小，有些是按照时间，当然这是一个解释，另外一种解释就是，虽然设置了上限，但是有兜底上限，即到触发设置的上限时，兜底上限就触发了（先触发上限，这个才会触发），使得可以超过一点，给错误一些位置（而不是等待错误出现），那么由于错误出现的快慢（程序的任何因素基本都会影响），而导致出现的浮动（当然，错误出现之前需要停止他的执行使得停止打印，所以错误后，没有对应打印了），一般考虑的是兜底上限，而不是栈帧不一，因为错误最后也有打印，那么一般是兜底上限的打印了（即他会进行操作，一般是设置的某个比例，打印完后，一般自动结束程序）
        //当然，兜底可能有，但是上面的解释并不是一定正确，只是有一点道理的而已，忽略即可
        main(args); //无限递归，虽然入口是这个main方法，但并不是不能递归哦
    }
}


//注意：对应的错误是Exception in thread "main" java.lang.StackOverflowError，一般来说虚拟机栈和本地方法栈有他们，因为他是用来考虑栈溢出的，所以在前面的图片中他才在异常对应的下面给他们这个

package com.test1;

/**
 *
 */
public class PC {
    public static void main(String[] args) {
        int x = 1;
        int y = 2;
        System.out.println(x+y);
    }
}

 0 iconst_1
 1 istore_1
 2 iconst_2
 3 istore_2
 4 getstatic #2 <java/lang/System.out : Ljava/io/PrintStream;>
 7 iload_1
 8 iload_2
 9 iadd
10 invokevirtual #3 <java/io/PrintStream.println : (I)V>
13 return

package com.test1;

/**
 *
 */
public class StackDemo2 {
    public static void main(String[] args) {
        int i = 1;
        int j = 2;
        int l = j;
        int z = i + j;
    }
}

 0 iconst_1
 1 istore_1
 2 iconst_2
 3 istore_2
 4 iload_2
 5 istore_3 //对应的值给z了，一般3后面就是直接的4了，不加_了（规定的，节省一些数）
 6 iload_1 //很明显，这个1也是代表x，而不是具体的数字
 7 iload_2
 8 iadd
 9 istore 4
11 return
//即除了iconst外，iload和iadd都可以使得保留数据操作，从而相应istore可以进行赋值

package com.test1;

/**
 *
 */
public class DynamicLink {
    public static void main(String[] args) {
        Math.random();
    }
}


//对应的字节码信息（我们主要看对应的main说明的字节码，以后也是这样的，即以后不提醒了）
0 invokestatic #2 <java/lang/Math.random : ()D>
3 pop2 //大胆猜测是对应的里面的底层特殊变量（可能共有）得到值，若有返回，那么就是操作对应的值，即他代表方法的默认返回值，只是没有人得到而已，一般来说之前的istore_1中的is的i代表他是int类型，若是其他引用类型一般代表a开头，其他基本类型按照首字母小写开头
4 return
//我们点击这个#2，可以到常量池中，如下：

package com.test1;

/**
 *
 */
public class TestVm {
    public static void main(String[] args) {
        //补充
        //byte[] b=new byte[5*1024*1024];
        //System.out.println("分配了1M空间给数组");
        System.out.println(Runtime.getRuntime()); //他是私有的构造
        System.out.print("Xmx=");
        //Runtime.getRuntime()可以取得当前JVM的运行时环境，这也是在Java中唯一一个得到运行时环境的方法
        //Runtime.getRuntime.maxMemory：
        //Java虚拟机能构从操作系统那里挖到的可用的最大内存，最大堆（的）大小，以字节为单位，如果内存本身没有限制，则返回值Long.MAX_VALUE
        //即@Native public static final long MIN_VALUE = 0x8000000000000000L;，也就是long的最大数（正的，不是负的），操作下面的两个除号，结果是8 7960 9302 2207，即8万亿mb，比内存大多了
        /*
        long最大是2^63-1=922 3372 0368 5477 5807
        922 3372 0368 5477 5807
            除以1024，大致得如下：取整的（因为反过来乘就不对了，可以自己测试）
            9007 1992 5474 0991 以这个整数为例
               除以1024，大致得如下：取整的（因为反过来乘就不对了，可以自己测试）
               8 7960 9302 2207
         */
        System.out.println(Runtime.getRuntime().maxMemory() / 1024.0 / 1024 + "M");
        System.out.print("free mem=");
        //Runtime.getRuntime.freeMemory：
        //已经占用，但实际并未使用的内存，也就是没有使用的内存（调用gc可能会增加他的值，因为去申请内存了），也就是说，内存我拿过来了，但是你可能没有使用，只是这个内存被你分配了，即只能给你，但不能给其他人，可能你并没有使用他
        //一般情况下，内存是挖多少用多少，但是也可以是挖多点，但我不使用
        System.out.println(Runtime.getRuntime().freeMemory() / 1024.0 / 1024 + "M");
        System.out.print("total mem=");
        //Runtime.getRuntime.totalMemory：
        //已占用的内存，初始堆大小（默认的，因为有最小的）
        System.out.println(Runtime.getRuntime().totalMemory() / 1024.0 / 1024 + "M");

        /*
        注意：
        JVM最大分配的堆内存由-Xmx指定，默认是物理内存的1/4（如当前电脑的总内存）
        -Xmx 也指 maxMemory的值（maxMemory()方法）
        但是，maxMemory的值一般会小于-Xmx（总要留有一点余地，除非由最小值来操作了或者快满了，比如最大和最小都是一样的，那么就是该值了，后面设置年轻代和老年代的比例时的配置就是如此，注意：虽然最大最小也是小于该值（快满了也是），但大于maxMemory的值，虽然冗余少点）

        JVM初始分配的堆内存由-Xms指定，默认是物理内存的1/64
        默认空余堆内存小于40%时，JVM就会增大堆（继续挖），直到-Xmx的最大限制，那么不会挖（那么这个40%就不会进行拦截了）
        而正是不会直接增大到最大限制，所以Runtime.getRuntime().freeMemory()的实际未占用的，只是代表当前最大的剩余，所以程序执行的结果，他们两个相加一般不会是maxMemory()的结果
         */
    }

}

Xmx=2012.0M
free mem=122.03204345703125M //这个地方可以自己来操作创建对象来验证是否改变他的值，通过验证，就算是对应的一个String aa = new String("1");都可能使得他减少（可能会增加，调用gc了，具体可以百度，测试的体量太小了，可能并不能完全测试出减少的情况，所以在后面的分配5m（体量够大了）中会出现减少，当然并不决定，如果你消耗的内存比申请的少，那么他还是会提升的，所以该值的提升与否不重要，因为他只是记录剩余没有使用的而已，而又因为会提高上限，所以他的值并不能预测提高还是减少，这里了解即可）
total mem=126.0M //由于他没有具体的小数值（可能是忽略的，所以看不出来）

Xmx=20.0M
free mem=4.757331848144531M
total mem=6.0M

   byte[] b=new byte[5*1024*1024];
        System.out.println("分配了5M空间给数组");

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space

package com.test1;

/**
 *
 */
//这里重新创建一个
public class test {
    public static void main(String[] args) {
        System.out.print("Xmx=");
        System.out.println(Runtime.getRuntime().maxMemory() / 1024.0 / 1024 + "M");
        System.out.print("free mem=");
        System.out.println(Runtime.getRuntime().freeMemory() / 1024.0 / 1024 + "M");
        System.out.print("total mem=");
        System.out.println(Runtime.getRuntime().totalMemory() / 1024.0 / 1024 + "M");
    }
}

package com.test2;

/**
 *  这里我们来考虑设置，以及年轻代中，eden和form和to的比例
 */
public class test {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("hello");
        Thread.sleep(30000); //最好再大一点
    }
}

package com.test2;

import java.io.Serializable;

/**
 *
 */
public class test1 extends Object implements Serializable {
    private static String name = "hello java"; //静态的变量，使用右键来创建相应的构造方法，是不会有提示的

    public test1(String name) {
        this.name = name;
    }

    public static void main(String[] args) {
        int x = 100;
        int y = 100;
        int result = testSum(x, y);
        System.out.println(result);
    }

    public static int testSum(int x, int y) {
        return x + y;
    }
}

Classfile xxx/test1.class //xxx目录省略了，操作的文件所在地址
  Last modified 2023年2月13日; size 869 bytes //操作日期和文件大小
  MD5 checksum 19036838a5b651f22b003899693cf060 //检验的数字（这里可能代表该唯一的文件编号，可能是区别文件的主要信息，因为一般不会根据地址来进行区分，因为你可以在其他地方操作该文件class的执行（那么地址变了），所以需要这个）
Compiled from "test1.java" //编译的文件是（来自）test1.java
public class com.test2.test1 implements java.io.Serializable //类的完整路径com.test2.test1
  minor version: 0
  major version: 52
  flags: (0x0021) ACC_PUBLIC, ACC_SUPER //类修饰符ACC_PUBLIC（public），如果么有public，即按照默认1，那么没有这个ACC_PUBLIC，前面的(0x0021)可能改变成0x0020，ACC_SUPER是默认有的，代表是类
  this_class: #8                          // com/test2/test1
  super_class: #2                         // java/lang/Object
  interfaces: 1, fields: 1, methods: 4, attributes: 1
      //下面这个Constant pool:代表常量池（运行时常量池，因为只有运行才会出现，所以我们通常也称他为运行时常量池，虽然其他基本都是运行出现的，但是他在变量上比较特殊，所以我们愿意加上运行时）
Constant pool:
   #1 = Methodref          #2.#3          // java/lang/Object."<init>":()V
   #2 = Class              #4             // java/lang/Object
   #3 = NameAndType        #5:#6          // "<init>":()V
   #4 = Utf8               java/lang/Object
   #5 = Utf8               <init>
   #6 = Utf8               ()V
   #7 = Fieldref           #8.#9          // com/test2/test1.name:Ljava/lang/String;
   #8 = Class              #10            // com/test2/test1
   #9 = NameAndType        #11:#12        // name:Ljava/lang/String;
  #10 = Utf8               com/test2/test1
  #11 = Utf8               name
  #12 = Utf8               Ljava/lang/String;
  #13 = Methodref          #8.#14         // com/test2/test1.testSum:(II)I
  #14 = NameAndType        #15:#16        // testSum:(II)I
  #15 = Utf8               testSum
  #16 = Utf8               (II)I
  #17 = Fieldref           #18.#19        // java/lang/System.out:Ljava/io/PrintStream;
  #18 = Class              #20            // java/lang/System
  #19 = NameAndType        #21:#22        // out:Ljava/io/PrintStream;
  #20 = Utf8               java/lang/System
  #21 = Utf8               out
  #22 = Utf8               Ljava/io/PrintStream;
  #23 = Methodref          #24.#25        // java/io/PrintStream.println:(I)V
  #24 = Class              #26            // java/io/PrintStream
  #25 = NameAndType        #27:#28        // println:(I)V
  #26 = Utf8               java/io/PrintStream
  #27 = Utf8               println
  #28 = Utf8               (I)V
  #29 = String             #30            // hello java //看这里
  #30 = Utf8               hello java //到这里，连接的（链接，动态链接）
  #31 = Class              #32            // java/io/Serializable
  #32 = Utf8               java/io/Serializable
  #33 = Utf8               (Ljava/lang/String;)V
  #34 = Utf8               Code
  #35 = Utf8               LineNumberTable
  #36 = Utf8               LocalVariableTable
  #37 = Utf8               this
  #38 = Utf8               Lcom/test2/test1;
  #39 = Utf8               main
  #40 = Utf8               ([Ljava/lang/String;)V
  #41 = Utf8               args
  #42 = Utf8               [Ljava/lang/String;
  #43 = Utf8               x
  #44 = Utf8               I
  #45 = Utf8               y
  #46 = Utf8               result
  #47 = Utf8               <clinit>
  #48 = Utf8               SourceFile
  #49 = Utf8               test1.java
{
    //上面很明显说明的是类，那么这里就是构造方法了
  public com.test2.test1(java.lang.String); //构造方法对应的类地址和参数地址
    descriptor: (Ljava/lang/String;)V
    flags: (0x0001) ACC_PUBLIC //构造方法修饰类型
    Code:
      stack=1, locals=2, args_size=2
         0: aload_0 //参数变量加载
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V 这里就代表进入某种方法的意思，而不是得到结果
         4: aload_0 //继续加载上面的变量，因为上面变量已经赋值了
         5: pop //虽然是上面方法的底层返回给他的底层特殊变量（可能共有），但是什么都没有做，即空返回
         6: aload_1 //代表this
         7: putstatic     #7                  // Field name:Ljava/lang/String; 对于静态来说就是初始化name
        10: return //操作返回
      LineNumberTable:
        line 11: 0
        line 12: 4
        line 13: 10
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      11     0  this   Lcom/test2/test1;
            0      11     1  name   Ljava/lang/String;

  public static void main(java.lang.String[]); //同样的有地址java.lang.String
    descriptor: ([Ljava/lang/String;)V //代表没有返回类型即V
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC //两个类型	
    Code:
      stack=2, locals=4, args_size=1
         0: bipush        100 //一些特别的，他可能是不同的显示，如数值100等等
         2: istore_1 //一些特别的，他可能是不同的显示，如第4个变量等等
         3: bipush        100
         5: istore_2
         6: iload_1
         7: iload_2
         8: invokestatic  #13                 // Method testSum:(II)I，自带的有，那么不需要获取什么
        11: istore_3 //执行方法是可以操作赋值的，那么可以直接这样，就如return可以得到一样，前提是对应方法会返回，虽然这里代表没有返回
        12: getstatic     #17                 // Field java/lang/System.out:Ljava/io/PrintStream;
        15: iload_3
        16: invokevirtual #23                 // Method java/io/PrintStream.println:(I)V
        19: return
      LineNumberTable:
        line 16: 0
        line 17: 3
        line 18: 6
        line 19: 12
        line 20: 19
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      20     0  args   [Ljava/lang/String;
            3      17     1     x   I
            6      14     2     y   I
           12       8     3 result   I

  public static int testSum(int, int);
    descriptor: (II)I //返回的类型，前提是有返回类型他才会有，否则一般代表V，一般情况下，其他类型是按照首字母大写的，比如double，那么这里是D，但是若是Double，那么是对应的类的地址，那么只要是地址，即后面的基本都是areturn（不只是仅限于String哦），一般来说开头就是a，注意：一般变量也是这样，但凡是操作对应的，那么首字母基本都是这里的类似说明，你看看后面的字节码信息就知道了，就如iload_0必然是加载int类型的（首字母是i，而返回的类型，如这里就是I，那么是ireturn，而在具体Code里面一般是小写，外面（descriptor）通常是大写）
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC //同样的
    Code:
      stack=2, locals=2, args_size=2
         0: iload_0
         1: iload_1
         2: iadd
         3: ireturn //这里就是返回了，返回结果，即将加载并操作的进行返回，一般来说areturn代表操作String的返回，而这里ireturn代表int的返回，具体其他类型，可以自己看看
      LineNumberTable:
        line 23: 0
      LocalVariableTable: //局部变量表
        Start  Length  Slot  Name   Signature
            0       4     0     x   I
            0       4     1     y   I

  static {}; //静态区域
    descriptor: ()V //没有返回值
    flags: (0x0008) ACC_STATIC //自然是静态的
    Code:
      stack=1, locals=0, args_size=0
         0: ldc           #29                 // String hello java   值
         2: putstatic     #7                  // Field name:Ljava/lang/String;   变量，并不是定义的变量哦，通过引用可以找到变量，即name
         5: return //进行赋值，很明显，他是与方法相同的，所以我们一般会说静态在类加载时就加载了
      LineNumberTable:
        line 9: 0
}
SourceFile: "test1.java" //源文件名称（不是总地址了，提取文件名称出来了，当然，前面可能也指定了编译的该名称，但是参数是各有作用的，他代表编译者，这里代表名称者，可能该名称是可以进行改变的，具体可以百度找差异）

       //上面不只是针对main方法哦，所以你操作插件中会出现多个对应的方法

jps  #是java提供的一个显示当前所有java进程pid的命令
jinfo -flag PermSize 进程号  #查看进程的PermSize初始化空间大小
jinfo -flag MaxPermSize 进程号 #查看PermSize最大空间

jps   #查看进程号
jinfo -flag MetaspaceSize 进程号   #查看Metaspace 最大分配内存空间
jinfo -flag MaxMetaspaceSize 进程号 #查看Metaspace最大空间

package com.test2;

/**
 *
 */
public class test3 {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("Hello World");
        Thread.sleep(200000);
    }
}

Constant pool:
   #1 = Methodref          #2.#3          // java/lang/Object."<init>":()V
   #2 = Class              #4             // java/lang/Object
   #3 = NameAndType        #5:#6          // "<init>":()V
   #4 = Utf8               java/lang/Object
   #5 = Utf8               <init>
   #6 = Utf8               ()V
   #7 = Fieldref           #8.#9          // com/test2/test1.name:Ljava/lang/String;
   #8 = Class              #10            // com/test2/test1
   #9 = NameAndType        #11:#12        // name:Ljava/lang/String;
  #10 = Utf8               com/test2/test1
  #11 = Utf8               name
  #12 = Utf8               Ljava/lang/String;
  #13 = Methodref          #8.#14         // com/test2/test1.testSum:(II)I
  #14 = NameAndType        #15:#16        // testSum:(II)I
  #15 = Utf8               testSum
  #16 = Utf8               (II)I
  #17 = Fieldref           #18.#19        // java/lang/System.out:Ljava/io/PrintStream;
  #18 = Class              #20            // java/lang/System
  #19 = NameAndType        #21:#22        // out:Ljava/io/PrintStream;
  #20 = Utf8               java/lang/System
  #21 = Utf8               out
  #22 = Utf8               Ljava/io/PrintStream;
  #23 = Methodref          #24.#25        // java/io/PrintStream.println:(I)V
  #24 = Class              #26            // java/io/PrintStream
  #25 = NameAndType        #27:#28        // println:(I)V
  #26 = Utf8               java/io/PrintStream
  #27 = Utf8               println
  #28 = Utf8               (I)V
  #29 = String             #30            // hello java //看这里
  #30 = Utf8               hello java //到这里，连接的（链接，动态链接）
  #31 = Class              #32            // java/io/Serializable
  #32 = Utf8               java/io/Serializable
  #33 = Utf8               (Ljava/lang/String;)V
  #34 = Utf8               Code
  #35 = Utf8               LineNumberTable
  #36 = Utf8               LocalVariableTable
  #37 = Utf8               this
  #38 = Utf8               Lcom/test2/test1;
  #39 = Utf8               main
  #40 = Utf8               ([Ljava/lang/String;)V
  #41 = Utf8               args
  #42 = Utf8               [Ljava/lang/String;
  #43 = Utf8               x
  #44 = Utf8               I
  #45 = Utf8               y
  #46 = Utf8               result
  #47 = Utf8               <clinit>
  #48 = Utf8               SourceFile
  #49 = Utf8               test1.java

public static void main(java.lang.String[]); 
    descriptor: ([Ljava/lang/String;)V 
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC 
    Code:
      stack=2, locals=4, args_size=1
         0: bipush        100 
         2: istore_1 
         3: bipush        100
         5: istore_2
         6: iload_1
         7: iload_2      
                  //这下面的#13就是利用了常量池，即对该常量池表的符号引用
         8: invokestatic  #13                 // Method testSum:(II)I
        11: istore_3 
        12: getstatic     #17                 // Field java/lang/System.out:Ljava/io/PrintStream;
        15: iload_3
        16: invokevirtual #23                 // Method java/io/PrintStream.println:(I)V
        19: return
      LineNumberTable:
        line 16: 0
        line 17: 3
        line 18: 6
        line 19: 12
        line 20: 19
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      20     0  args   [Ljava/lang/String;
            3      17     1     x   I
            6      14     2     y   I
           12       8     3 result   I

 0 new #7 <com/test1/PC> //这个创建对象
 3 dup //这个代表相应类型的变量得值，即创建引用指向该对象
     //而只有这个得到值后，我们才可以进行他的数值提取，以及加载，如astore_1，aload_1，当然，他们都不是类似于iconst_1的，所以是第一个变量（astore_1，a开头的前面说明过了，代表类类型）

public class Solution {
    public void method() {
        System.out.println("are you ok");
   }
}

/**
 * 设置最大堆最小堆：-Xms20m -Xmx20m，先后顺序不重要，他只要可以识别的即可，就如原来是2+1=3，而你操作1+2=3，结果都是一样的，只是一个从先看到2（大，Xmx），一个先看到1（小，Xms），到从先看到1（小，Xms），一个先看到2（大，Xmx）了
 即-Xmx20m -Xms20m到-Xms20m -Xmx20m这样的意思，结果反正都是设置的意思，只是是否先后设置而已，所以先后顺序不重要，重要的是结果（过程不重要，拿到结果才重要）
 */

public class HeapOOM {
    static class OOMObject {
   }
    public static void main(String[] args) {
        List<OOMObject> oomObjectList = new ArrayList<>();
        while (true) {
            oomObjectList.add(new OOMObject());
       }
   }
}

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space

package com.test3;

/**
 *
 */
public class JavaVMStackSOF {
    private int stackLength = 1;

    public void stackLeak() {

        stackLength++;
        stackLeak();
    }

    public static void main(String[] args) throws Throwable {
        JavaVMStackSOF oom = new JavaVMStackSOF();
        try {
            oom.stackLeak();
        } catch (Throwable e) {
            System.out.println("stack length:" + oom.stackLength);
            throw e; //在try里面进行抛出，并打印错误信息，由于是try里面的，那么main方法里不用操作抛出（因为有最终归属了，而不用然jvm来处理），即直接的打印错误信息
        }
    }
}

//可以选择设置-Xss128k

The Java thread stack size specified is too small. Specify at least 180k
    //翻译：指定的Java线程堆栈大小太小，指定至少180k（大于等于180k）

package com.test3;

/**
 *
 */
public class JavaVMStackSOF1 {
    private static int stackLength = 0;

    public static void test() {
        long unused1, unused2, unused3, unused4, unused5,
        unused6, unused7, unused8, unused9, unused10,
        unused11, unused12, unused13, unused14, unused15,
        unused16, unused17, unused18, unused19, unused20,
        unused21, unused22, unused23, unused24, unused25,
        unused26, unused27, unused28, unused29, unused30,
        unused31, unused32, unused33, unused34, unused35,
        unused36, unused37, unused38, unused39, unused40,
        unused41, unused42, unused43, unused44, unused45,
        unused46, unused47, unused48, unused49, unused50,
        unused51, unused52, unused53, unused54, unused55,
        unused56, unused57, unused58, unused59, unused60,
        unused61, unused62, unused63, unused64, unused65,
        unused66, unused67, unused68, unused69, unused70,
        unused71, unused72, unused73, unused74, unused75,
        unused76, unused77, unused78, unused79, unused80,
        unused81, unused82, unused83, unused84, unused85,
        unused86, unused87, unused88, unused89, unused90,
        unused91, unused92, unused93, unused94, unused95,
        unused96, unused97, unused98, unused99, unused100;
        stackLength++;
        test();
        unused1 = unused2 = unused3 = unused4 = unused5 =
        unused6 = unused7 = unused8 = unused9 = unused10 =
        unused11 = unused12 = unused13 = unused14 = unused15 =
        unused16 = unused17 = unused18 = unused19 = unused20 =
        unused21 = unused22 = unused23 = unused24 = unused25 =
        unused26 = unused27 = unused28 = unused29 = unused30 =
        unused31 = unused32 = unused33 = unused34 = unused35 =
        unused36 = unused37 = unused38 = unused39 = unused40 =
        unused41 = unused42 = unused43 = unused44 = unused45 =
        unused46 = unused47 = unused48 = unused49 = unused50 =
        unused51 = unused52 = unused53 = unused54 = unused55 =
        unused56 = unused57 = unused58 = unused59 = unused60 =
        unused61 = unused62 = unused63 = unused64 = unused65 =
        unused66 = unused67 = unused68 = unused69 = unused70 =
        unused71 = unused72 = unused73 = unused74 = unused75 =
        unused76 = unused77 = unused78 = unused79 = unused80 =
        unused81 = unused82 = unused83 = unused84 = unused85 =
        unused86 = unused87 = unused88 = unused89 = unused90 =
        unused91 = unused92 = unused93 = unused94 = unused95 =
        unused96 = unused97 = unused98 = unused99 = unused100 = 0;

    }
    public static void main(String[] args) {
        try {
            test();
        }catch (Error e){
            System.out.println("stack length:" + stackLength);
            throw e;
        }
  }

}

stack length:3716
java.lang.OutOfMemoryError

package com.test3;

/**
 *
 */
public class JavaVMStackOOM {
    private void dontStop() {
        while (true) {
        }
    }

    public void stackLeakByThread() {
        while (true) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    dontStop();
                }
            });
            thread.start();
        }
    }

    public static void main(String[] args) throws Throwable {
        JavaVMStackOOM oom = new JavaVMStackOOM();
        oom.stackLeakByThread();
    }

}

//这里给出结果
Exception in thread "main" java.lang.OutOfMemoryError: unable to create native thread

package com.test3;

import java.util.HashSet;
import java.util.Set;
import java.util.function.Function;

/**
 * -XX:PermSize=6M -XX:MaxPermSize=6M
 */
public class RuntimeConstantPoolOOM {
    public static void main(String[] args) {
        // 使用Set保持着常量池引用， 避免Full GC回收对应常量池行为（他可是可以操作方法区的）
        Set<String> set = new HashSet<String>();
        // 在short范围内足以让6MB的PermSize产生OOM了
        short i = 0;
        while (true) {
            set.add(String.valueOf(i++).intern());
        }
    }

}

package com.test3;

import java.util.HashSet;
import java.util.Set;
import java.util.function.Function;

/**
 * -XX:MetaspaceSize=9m -XX:MaxMetaspaceSize=9m（设置一样，使得基本不会扩展上限了（注意：一般有最小最大的说明，基本都是上限慢慢加，而相同，则说明不会加了，因为你一开始就到达最顶峰了，自然没有扩展的意思了），如果最小的大于最大的，那么最大的自动设置成最小的，即相同，其他的也是如此，如堆等等，前提有最小的设置，栈好像没有），一般来说MaxMetaspaceSize不能太小，就如"指定的Java线程堆栈大小太小，指定至少180k"一样，他一般好像是9m这里，8m就不行了，总要有一个空间的，而堆好像是2m，1m就不行了，当然，他们的最小的若小于这些，那么默认将他们最小的变成这些
 即栈180k
 堆2m（可能可以更少，比如到k，这里先这样的认为）
 方法区9m（可能可以更少，比如到k，这里先这样的认为）
 */
public class RuntimeConstantPoolOOM {
    public static void main(String[] args) {
        // 使用Set保持着常量池引用， 避免Full GC回收对应常量池行为（他可是可以操作方法区的）
        Set<String> set = new HashSet<String>();
        // 若在short范围内不足以让9MB的MetaspaceSize产生OOM（注意在这个版本下执行是不对的，你先认为是对的，后面会给出说明，让你重新的更正），那么可以扩大范围，如变成int，short是2 ^16=65536，也就是操作添加65536个，可能比9m少，在前面我们知道"8个栈帧（一般认为是空方法）内存大概是1k内存"这个地方，但是这里是对应的运行时常量池，也就是方法区的保存，而如果short没有出现错误，可以修改成int，因此我并不能确定一个字面值是多少内存，通常来说short可以满足6m，6291456=6m，6291456/65536=96（没有余数），即一个字面值大概大于96字节数，这里你可以自己测试，经过我的测试，一般9m就不会报错，其中9m=9437184，9437184/65536=144，也就是可以得出结论，一个字面值内存空间大约在96到144字节之间，注意，在程序中，只会使用内存空间，因为硬盘空间是保存信息的，程序的信息可不会在文件里面（没有操作文件的话），通过增加字符串值，会发现，同样如此，因为一个String他占的空间是一个足够开辟大的（就算你自身的数比较小，也是这样大），就如局部变量表中，一个int他占用一个空间（虽然可能与类型有关），无论你int多大，都是这样
        int i = 0;
        while (true) {
            set.add(String.valueOf(i++).intern());
        }
    }

}

Exception in thread "main" java.lang.OutOfMemoryError: PermGen space //前面的jdk6的，一般很快就出现了
    //space：空间

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space

Exception in thread "main" java.lang.OutOfMemoryError: GC overhead limit exceeded
    //GC overhead limit exceeded：英文意思：超过GC开销限制

package com.test3;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 *
 */
public class JavaMethodAreaOOM {
    public static void main(String[] args) {
        while (true) {
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(OOMObject.class); //类
            enhancer.setUseCache(false); //缓存
            enhancer.setCallback(new MethodInterceptor() {
                @Override
                public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                    return methodProxy.invokeSuper(o, args);
                }


            });
            //主要代码
            enhancer.create(); //创建代理对象，也就是说一直帮你创建对象（可以认为他帮你生成class文件执行或者生成java文件再编译成class文件执行）
        }
    }

    static class OOMObject {
    }

}

Exception in thread "main" java.lang.OutOfMemoryError: Metaspace //再某些jdk版本下，可能上面的26行，即enhancer.create();，可能也会报一些他自己独有的错误，虽然一般是同时出现（可能一般在前面先出现）

package com.test3;

import sun.misc.Unsafe;

import java.lang.reflect.Field;

/**
 *
 */
public class DirectMemoryOOM {
    private static final int _1MB = 1024 * 1024;

    public static void main(String[] args) throws Exception {
        //Field[] getDeclaredFields()，用于获取此Class对象所表示类中所有成员变量信息
        Field unsafeField = Unsafe.class.getDeclaredFields()[0]; //只有这样，我们才可以直接的得到并使用Unsafe
        //void setAccessible(booleanflag)，当实参传递true时，则反射对象在使用时应该取消 Java 语言访问检查
//设置可以访问private变量的变量值，在jdk8之前可能不用设置，但是之后（包括jdk8）不能直接的访问私有属性了，因为需要进行设置这个，所以不能直接访问私有属性了
        unsafeField.setAccessible(true);
        //Object get(Object obj)，获取参数对象obj中此Field对象所表示成员变量的数值
        Unsafe unsafe = (Unsafe) unsafeField.get(null);
        while (true) {
            //真正申请分配内存的方法是Unsafe的allocateMemory()
            unsafe.allocateMemory(_1MB); //具体作用是：给堆外分配内存，也就是认为使用了直接内存
            //至于作用，可以看这个博客：https://www.jianshu.com/p/558d323430eb，记得自己找到哦，建议全局搜索"通过allocateMemory方法"或者"unsafe.allocateMemory(size * INT_SIZE_IN_BYTES);"，看他解释即可
        }
    }

}

Exception in thread "main" java.lang.OutOfMemoryError

package com.test4;

/**
 *
 */
public class test1 {
    public static void main(String[] args) {
        System.out.println("hello");
    }
}

[Opened C:\Program Files\Java\jdk1.8.0\jre\lib\rt.jar]
[Loaded java.lang.Object from C:\Program Files\Java\jdk1.8.0\jre\lib\rt.jar]
[Loaded java.io.Serializable from C:\Program Files\Java\jdk1.8.0\jre\lib\rt.jar]
[Loaded java.lang.Comparable from C:\Program Files\Java\jdk1.8.0\jre\lib\rt.jar]
[Loaded java.lang.CharSequence from C:\Program Files\Java\jdk1.8.0\jre\lib\rt.jar]
[Loaded java.lang.String from C:\Program Files\Java\jdk1.8.0\jre\lib\rt.jar]
[Loaded java.lang.reflect.AnnotatedElement from C:\Program Files\Java\jdk1.8.0\jre\lib\rt.jar]
[Loaded java.lang.reflect.GenericDeclaration from C:\Program Files\Java\jdk1.8.0\jre\lib\rt.jar]
[Loaded java.lang.reflect.Type from C:\Program Files\Java\jdk1.8.0\jre\lib\rt.jar]
[Loaded java.lang.Class from C:\Program Files\Java\jdk1.8.0\jre\lib\rt.jar]

public class A {
         static int a;
         public static void main(String[] args) {
             System.out.println(a);
       }
     }

public class B {
 
     public static void main(String[] args) {
         int a;
         System.out.println(a);
     }
 }

package com.test4;

/**
 *
 */
public class TestMain {
    private static int i;
    private double d;

    public static void print() {
    }

    private boolean trueOrFalse() {
        return false;
    }

}

Constant pool:
   #1 = Methodref          #3.#20         // java/lang/Object."<init>":()V
   #2 = Class              #21            // com/test4/TestMain
   #3 = Class              #22            // java/lang/Object
   #4 = Utf8               i
   #5 = Utf8               I
   #6 = Utf8               d
   #7 = Utf8               D
   #8 = Utf8               <init>
   #9 = Utf8               ()V
  #10 = Utf8               Code
  #11 = Utf8               LineNumberTable
  #12 = Utf8               LocalVariableTable
  #13 = Utf8               this
  #14 = Utf8               Lcom/test4/TestMain;
  #15 = Utf8               print
  #16 = Utf8               trueOrFalse
  #17 = Utf8               ()Z
  #18 = Utf8               SourceFile
  #19 = Utf8               TestMain.java
  #20 = NameAndType        #8:#9          // "<init>":()V
  #21 = Utf8               com/test4/TestMain
  #22 = Utf8               java/lang/Object

public class TestClinit {
 static {
 i = 0; // 给变量（只能是静态变量，因为这里是静态代码块，当然，他会先识别是否有操作到i的情况，编译期，运行期会保留，不会考虑，因为是慢慢执行过去的）复制可以正常编译通过

 System.out.print(i); // 这句编译器会提示"非法向前（正向）引用"，也就是说，静态块必须满足先后顺序才可打印对应的变量，这是对打印来说的，即打印满足先后顺序，这是打印的限制

 }
 static int i = 1;
}

//实际上只是针对访问来说的，访问需要顺序，但是修改不会，因为访问需要符号顺序，从而进行替换，而修改时，修改虽然可以修改，但是上面的结果还是1，因为在没有类型（static int）的情况下，保留了赋值的动作（编译器自动收集类中的所有类变量的赋值动作），当他有类型时，先操作之前的赋值，然后操作1的赋值，即他们总体来说就是按照顺序的，只是修改操作时，静态是保留动作的，使得他是一个特殊的不要类型就可以赋值的情况（在方法中必然是不行的，所以他是特殊的，底层代码基本都可以实现哦，不要觉得反常，因为他也是人操作出来的，自然也可以由人来修改），所以按照上面的情况，只要你将代码块放在后面就行，这样最后由于有类型，那么可以直接的赋值

//实际上不是静态的操作与静态同理（后续了），其中也会先操作默认值的（最先），也包括非法前向引用，要注意哦，在这个过程中一个类操作完构造方法他才算结束（或者到子，继续操作），这是保证实例的完整

//最后要注意的是，由于只需要考虑对应的执行完毕，所以就算再static中报错了，也不会导致程序结束，所以后面的代码会继续执行的

//这里也要注意：初始化时，Class类基本已经操作完毕，或者说操作了90%，而操作的90%中可以存在操作new对象，也就是说，在静态块中，可以进行创建对象，由于代码顺序原因，使得创建对象在一定程度是比静态先操作的，而并不是后操作，这里了解一下

package com.test4;

/**
 *
 */
public class TestClinit02 {
    static class Parent {
        public static int A = 1;

        static {
            A = 2;
        }
    }

    static class Sub extends Parent {
        public static int B = A; 
         public Sub(){
            System.out.println(1); //不会执行
        }
    }

    public static void main(String[] args) {
        System.out.println(Sub.B);  //使用，即前面的"或者变量使用，他也执行"（常量可不会哦），而直接的使用，必然是静态的，所以有时候我们也认为是使用静态变量，因为如果不是静态的，必然需要创建对象，那么还不是也操作初始化了
        //结果：上面打印了1（前提是执行到了，如System.out.println(new Sub().B);），和2
       
    }

}

package com.test4;

/**
 *
 */
public class TestDeadLoop {
    static class DeadLoopClass {
        static {
// 如果不加上这个if语句， 编译器将提示"Initializer does not complete normally"并拒绝编译，该英文意思是：初始化器未正常完成
            //为什么呢，实际上编译为class的检查并不是非常严谨的，有时候他并不会知道他是一直循环的，所以我们才会说"实际应用中这种阻塞往往是很隐蔽的"
            if (true) {
                System.out.println(Thread.currentThread() + "init DeadLoopClass"); //多次执行，可以看到不同的结果
                while (true) {
                }
            }
        }
    }

    public static void main(String[] args) {
        Runnable script = new Runnable() {
            public void run() {
                System.out.println(Thread.currentThread() + "start");
                DeadLoopClass dlc = new DeadLoopClass();
                System.out.println(Thread.currentThread() + " run over");
            }
        };
        Thread thread1 = new Thread(script);
        Thread thread2 = new Thread(script);
        thread1.start();
        thread2.start();
    }

}

package com.tets5;

/**
 *
 */
public class ParentA {
    static {
        System.out.println("1");
    }

    public ParentA() {
        System.out.println("2");
    }


}

class SonB extends ParentA { //没有public，当前文件的副本类，相当于一个文件操作两个类，虽然这个是副本，但是对应的public只是一个修饰而已，也就是访问权限而已，并没有什么作用
    static {
        System.out.println("a");
    }

    public SonB() {
        //如果父类只有 有参数的构造，那么这里需要手动加上super方法
        System.out.println("b");
    }

    public static void main(String[] args) {
        ParentA ab = new SonB(); //这个是ParentA ab = null时，对应的1，a也会出现，因为前面说明过了，即"其中main方法由于是必然执行的，也就是说，当前类一定有Class，所以若对应的静态代码块在当前类，那么他必然执行（在main方法之前）"
        ab = new SonB();
    }

}

//从上面可以看出，继承的父类也是创建对象的，或者存在副本，这也是为什么继承相同父类时，我们子类改变对应的值时，并不会改变其他继承父类的对应值的原因，即都是完全独立的关联

1
a
2
b
2
b

package com.tets5;

/**
 * 获取不同类加载器
 * 这里是jdk11，在不同版本下，可能打印信息不同
 */
public class test {
    public static void main(String[] args) {
        //获取系统类加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader); //jdk.internal.loader.ClassLoaders$AppClassLoader@2437c6dc

        //获取扩展加载器，即系统加载器的父加载器
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent); //jdk.internal.loader.ClassLoaders$PlatformClassLoader@39ba5a14
        //通过查看结果，发现，的确他们都是最终继承ClassLoader，也知道他们自己并没有互相联系，只是由于方法的联系，所以我们才会说：加载器划分为包含关系而并非继承关系，就是可以通过方法来获得的主要说明

        //获取启动类加载器
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1); //null，一般这个加载器通常不能获取，或者说，这个方式不能获取，他是最底层的加载器，可不能让你随便的操作哦

        //获取用户自定义的加载器，他的结果一般与系统加载器的结果一样，即自定义的，通过对自己类的操作加载器，可以知道给操作他，因为自定义就是操作我们的类的
        //所以一般这样是得到自定义的方式（对于该类来说，是自定义加载器，因为自定义是最后操作的类），那么一个Class可以被加载多次吗，答：只有1次的（虽然前面说明了），会判断的，每个类都有一个检验数字哦，一般生成Class时，可能会保留这个检验数字的，除非你是不同的类（包括不同目录的相同名称的类）
        ClassLoader classLoader = test.class.getClassLoader(); //很明显，你看到这个就明白，在前面操作时，的确可以通过Class来反过来获取
        System.out.println(classLoader); jdk.internal.loader.ClassLoaders$AppClassLoader@2437c6dc

        //核心类库使用的是启动类加载器，以String为例（他的上一个就是启动类，按照惯例，也可以说成是他的自定义的加载器）
        ClassLoader classLoader1 = String.class.getClassLoader();
        System.out.println(classLoader1); //null
    }
}

//即自定义加载器只是相对于类来说的，谁最后操作他，那么谁就是他的自定义加载器

package java.lang;

/**
 *
 */
public class String {
    static {
        System.out.println("我们自定义的String加载");
    }
}

package test;

/**
 *
 */
public class StringTest {
    public static void main(String[] args) {
        String s = new String();
        System.out.println("Stringtest");
    }
}

黑客自定义一个 java.lang.String 类，该 String 类具有系统的 String 类一样的功能，只是在某个函数稍作修改，比如 equals 函数，这个函数经常使用，如果在这个函数中，黑客加入一些"病毒代码"，并且通过自定义类加载器加入到JVM中，此时，如果没有双亲委派模型，那么 JVM 就可能误以为黑客自定义的java.lang.String 类是系统的 String 类（既然没有双亲委派模型，那么他并不认为String一定是加载的，或者说，没有加载，因为他没有操作父加载器），导致"病毒代码"被执行（比如遍历c盘文件，然后都删除）


package java.lang;

/**
 *
 */
public class String {
    static {
        System.out.println("我们自定义的String加载");
    }

    public static void main(String[] args) {
        System.out.println(1); //还是上面的，但是这里我们操作执行
    }
}

错误: 在类 java.lang.String 中找不到 main 方法, 请将 main 方法定义为:
   public static void main(String[] args)
否则 JavaFX 应用程序类必须扩展javafx.application.Application
//即他的确没有被加载，因为找不到

ClassLoader1，ClassLoader2都加载 java.lang.String类（可能是项目说明的包哦）或者其他相同的类，对应Class1、Class2对象，那么Class1对象不属于 ClassLoadr2对象加载的 java.lang.String 类型
    //一般由于先后顺序，所以之前才会说明"因为首先是最顶端的类加载器加载系统的 java.lang.String 类，最终自定义的类加载器无法加载 java.lang.String 类或者只会加载没有父的对应类的"
    //在后面会说明的

public Class<?> loadClass(String name) throws ClassNotFoundException {
        return loadClass(name, false);
}

protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) { //加锁，保证只有一人进入（类加载器可能有很多，特别是同级的，即主要是防止我们手动的操作）
            // First, check if the class has already been loaded
            Class<?> c = findLoadedClass(name); //查看是否加载了name名称的类（可以认为是全限定名），即先从缓存查找该class对象，找到就不用重新加载，一般代表当前加载器的缓存，这就是只会加载一次的原因

            if (c == null) {
                long t0 = System.nanoTime();
                try {
                    if (parent != null) { //看看有没有父类加载器
                        //如果找不到，则委托给父类加载器去加载
                        c = parent.loadClass(name, false); //父类继续操作是否加载，还是这个方法哦
                    } else {
                        //如果没有父类，则委托给启动加载器去加载，没有找到加载的，或者说，没有加载，自然也会返回null，虽然看起来他也有判断的成分，但是是因为操作的原因导致的
                        c = findBootstrapClassOrNull(name); 
                    }
                } catch (ClassNotFoundException e) {
                    // ClassNotFoundException thrown if class not found
                    // from the non-null parent class loader
                }

                if (c == null) { //如果上面没有加载，那么这里进入，说明没有加载器加载了
                    // If still not found, then invoke findClass in order
                    // to find the class.
                    long t1 = System.nanoTime();
                    //之前说过了"若有自定义，即从自定义开始的"，那么通过上面的查找，说明前面都没有加载，自然操作自定义的
                    // 如果都没有找到，则通过自定义实现的findClass去查找并加载，每个加载器都操作这个，一般来说，自定义我们自己操作，而扩展和应用，一般使用他们的父类的，通常是一般是URLClassLoader里面的该方法来加载自己	
                    c = findClass(name); //使用自己的加载器加载（没有加载自然也是null，与前面的findBootstrapClassOrNull基本类似，反正都是加载，只是findBootstrapClassOrNull代表启动，而这里代表不是启动的），很明显，这就是自定义或者不是启动的加载器的操作，这就是为什么最后会操作自定义和其他加载器的原因，与双亲委派联系起来，即该方法及其前面的代码，就是双亲委派的逻辑代码
                    /*
                    //这里考虑自定义的：
                     protected Class<?> findClass(String name) throws ClassNotFoundException {
        throw new ClassNotFoundException(name); //而正是因为他是默认报错的，所以我们自定义操作时，需要重写该方法来操作加载，记住，到这里说明是自定义加载器了，自然默认的this就是自定义的，所以是自定义的该方法
        这里一般代表加载（这里是操作加载的，与上面的findBootstrapClassOrNull是类似的作用，所以说到这里就可以了，后面的就不做说明，具体可以百度），他与loadClass都是ClassLoader里面的，而自定义加载器可是继承他ClassLoader的，自然若重写的话，会使用自定义加载器的findClass版本
    }
                    */

                    // this is the defining class loader; record the stats
                    PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    PerfCounter.getFindClasses().increment();
                }
            }
            if (resolve) { //是否需要在加载时进行解析，一般是false，看前面的return loadClass(name, false);
                resolveClass(c);
            }
            return c;
        }
    }

  protected final Class<?> defineClass(String name, byte[] b, int off, int len)
        throws ClassFormatError
    {
        return defineClass(name, b, off, len, null);
    }

/*
实现方式:
所有用户自定义类加载器都应该继承ClassLoader类
在自定义ClassLoader的子类是，我们通常有两种做法:
1：重写loadClass方法（是实现双亲委派逻辑的地方，修改他对应逻辑容易会破坏双亲委派机制，不推荐，因为你并不能可以好的操作，除非你复制粘贴过去，但比较麻烦）
2：重写findClass方法（推荐）
*/

package com.lagou.dome;

/**
 *
 */
public class Test {
    public static void main(String[] args) {
        System.out.println(1);
    }
}

package com.lagou.dome;

import java.io.*;

/**
 *
 */
public class MyClassLoader extends ClassLoader {
    //定义字节码文件的路径
    private String codePath;
    //定义构造方法

    public MyClassLoader(String codePath) {
        this.codePath = codePath;
    }

    //表示设置父加载器，这就是为什么之前说明自定义加载器时，没有特别说明他的父加载器是谁，因为，他可以不找父
    //所以自定义是特殊的，其他的加载器在运行时，一般都会默认操作，而自定义一般需要在main操作，这里补充前面没有说明可以不操作父加载器的说明
   
    public MyClassLoader(ClassLoader parent, String codePath) {
        super(parent);
        this.codePath = codePath;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        //声明输入流
        BufferedInputStream bis = null;
        //声明输出流
        ByteArrayOutputStream baos = null;
        try {
            //字节码路径
            String path = codePath + name + ".class";
            //初始化输入流
            bis = new BufferedInputStream(new FileInputStream(path));
            //初始化输出流
            baos = new ByteArrayOutputStream();
            //io读写操作
            int len;
            byte[] data = new byte[1024];
            while ((len = bis.read(data)) != -1) {
                baos.write(data, 0, len);
            }
            //获取内存中字节数组（得到的在这里，可没有指定文件哦，这是ByteArrayOutputStream的能力）
            byte[] byteCode = baos.toByteArray();
            //调用defineClass 将字节数组转成Class对象
            //第一个参数：一般不设置，设置为null即可，具体作用可以百度查看
            //第二个参数：存放我们读取class文件的字节数组
            //第三个参数：下标0开始操作
            //第四个参数：数组长度，即都操作
            Class<?> defineClass = defineClass(null, byteCode, 0, byteCode.length);
            return defineClass;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                baos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
        return null; //说明也加载不了，那么自然没有操作，即出现了某些问题
    }
}

package com.lagou.dome;

/**
 *
 */
public class ClassLoaderTest {
    //在main里面，也验证了"一般是从系统开始往上，若有自定义，即从自定义开始的（虽然需要他操作才行）"，而这个操作就是下面我们的手动操作，这个开始，需要存在父加载器，否则这里只会执行一次，虽然在启动之前（main执行之前），已经操作过了
    //而正是因为已经操作过了，所以说，一般已经加载的，我们是不可能继续加载了，只能自己操作自定义加载的操作了，因为反正执行父加载器也是没有用的，且相同的，父加载器优先操作
    public static void main(String[] args) {
        //很明显，这里是d盘，那么我们将之前运行得到的class代码放在d盘
        MyClassLoader classLoader = new MyClassLoader("d:/");
        try {
            //System.out.println(classLoader.findClass("Test").getName());
            //得到Class
            Class<?> clazz = classLoader.loadClass("Test"); //这里操作了该方法，且我们并没有重写，所以还是操作了父加载器

            //这个可以执行，但是需要注意的是：对应底层的方法defineClass一般只能操作一次，如果再次的操作会报错，这里要注意
//            System.out.println(classLoader.findClass("Test").getName());
            System.out.println(clazz.getName()); //com.lagou.dome.Test，获得Class全限定名
            System.out.println(clazz.getClassLoader().getClass()); //class com.lagou.dome.MyClassLoader，通过加载器来操作的话（这里是得到自定义加载器），那么是得到他的全限定名，要区分自定义哦
            System.out.println("我是由" + clazz.getClassLoader().getClass().getName() + "类加载器加载的"); //我是由com.lagou.dome.MyClassLoader类加载器加载的
            System.out.println(clazz); //class com.lagou.dome.Test
            System.out.println(String.class);//class java.lang.String
            String s = new String("1");
            System.out.println(s.getClass());//class java.lang.String
            System.out.println(clazz.getClassLoader().getClass()); //class com.lagou.dome.MyClassLoader
            //也就是说，通过加载器得到的Class结果，是加载器的（也就是说，我们自定义的加载他自身也有Class，一般情况下加载器都有自身的Class，一般来说自带的启动，扩展，系统中，启动会自动存在（c/c++操作的），既然有存在，自然可以操作将我们生成Class，所以可以说jvm默认给出Class（既然可以操作出来，那么手动的存在自然是合理的），要不然怎么操作呢），自然是他的全限定名，这是自然的，不要以为前面的加载并初始化是getClass的结果哦，那是实例的，记得看图哦

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

//部分代码：
public class Launcher {
    private static URLStreamHandlerFactory factory = new Launcher.Factory();
    //静态变量，初始化，会执行构造方法
    private static Launcher launcher = new Launcher();
    private static String bootClassPath = System.getProperty("sun.boot.class.path");
    private ClassLoader loader;
    private static URLStreamHandler fileHandler;

    public static Launcher getLauncher() {
        return launcher;
    }

    //构造方法执行
    public Launcher() {
        Launcher.ExtClassLoader var1;
        try {
            //初始化扩展类加载器
            var1 = Launcher.ExtClassLoader.getExtClassLoader();
            /*
             static class ExtClassLoader extends URLClassLoader {
             //该方法里面有个这个存在，return new Launcher.ExtClassLoader(var0);即的确会出现了Class，当前前提是启动类是有的，这也是为什么之前获得启动类加载器为null的原因，底层东西不会改变哦
        public static Launcher.ExtClassLoader getExtClassLoader() throws IOException {
            final File[] var0 = getExtDirs();
            
             private static File[] getExtDirs() {
            String var0 = System.getProperty("java.ext.dirs");，即扩展类加载器，的确是加载这个目录，前面也说过了"从java.ext.dirs系统属性所指定的目录中加载类库"
            
            对应的对象 
            public ExtClassLoader(File[] var1) throws IOException {
            super(getExtURLs(var1), (ClassLoader)null, Launcher.factory); //传递null当成自己父类，也就是不会得到启动类了，自己可以点击进去看，一般可以找到this.parent = var2;（ClassLoader类里面的）
            SharedSecrets.getJavaNetAccess().getURLClassPath(this).initLookupCache(this);
        }
            */
        } catch (IOException var10) {
            throw new InternalError("Could not create extension class loader", var10);
        }

        try {
            //初始化应用类加载器
            this.loader = Launcher.AppClassLoader.getAppClassLoader(var1); //参数代表设置父类
            /*
             public static ClassLoader getAppClassLoader(final ClassLoader var0) throws IOException {
             //操作的是该java.class.path，前面也说明了"它负责加载环境变量classpath或系统属性java.class.path 指定路径下的类库"
            final String var1 = System.getProperty("java.class.path"); 
            final File[] var2 = var1 == null ? new File[0] : Launcher.getClassPath(var1);
            return (ClassLoader)AccessController.doPrivileged(new PrivilegedAction<Launcher.AppClassLoader>() {
                public Launcher.AppClassLoader run() {
                    URL[] var1x = var1 == null ? new URL[0] : Launcher.pathToURLs(var2);
                    return new Launcher.AppClassLoader(var1x, var0); //看这里
                }
            });
        }
        
         AppClassLoader(URL[] var1, ClassLoader var2) {
            super(var1, var2, Launcher.factory); //最终也操作了this.parent = var2;，的确操作父类加载器
            this.ucp.initLookupCache(this);
        }
            */
        } catch (IOException var9) {
            throw new InternalError("Could not create application class loader", var9);
        }

        //设置ContextClassLoader，设置为当前加载器（根据上面的流程，那么就是应用加载器）
        Thread.currentThread().setContextClassLoader(this.loader);
        String var2 = System.getProperty("java.security.manager");
        if (var2 != null) {
            SecurityManager var3 = null;
            if (!"".equals(var2) && !"default".equals(var2)) {
                try {
                    var3 = (SecurityManager)this.loader.loadClass(var2).newInstance();
                } catch (IllegalAccessException var5) {
                } catch (InstantiationException var6) {
                } catch (ClassNotFoundException var7) {
                } catch (ClassCastException var8) {
                }
            } else {
                var3 = new SecurityManager();
            }

            if (var3 == null) {
                throw new InternalError("Could not create SecurityManager: " + var2);
            }

            System.setSecurityManager(var3);
        }

    }

/**
* var1 类全名
* var2 是否连接该类

*/ 
public Class<?> loadClass(String var1, boolean var2) throws ClassNotFoundException {
            int var3 = var1.lastIndexOf(46);
            if (var3 != -1) {
                SecurityManager var4 = System.getSecurityManager();
                if (var4 != null) {
                    var4.checkPackageAccess(var1.substring(0, var3));
                }
            }

    //一般都是false，想要返回TRUE可能需要设置启动参数lookupCacheEnabled为true，为true时，具体的逻辑也是C++写的，所以做了什么就不进行说明了
            if (this.ucp.knownToNotExist(var1)) {
                //如果这个类已经被这个类加载器加载，则返回这个类，否则返回Null
                Class var5 = this.findLoadedClass(var1);
                if (var5 != null) {
                    if (var2) {
                        this.resolveClass(var5); //如果该类没有被link（连接），则连接，否则什么都不做
                    }

                    return var5;
                } else {
                    throw new ClassNotFoundException(var1);
                }
            } else {
                return super.loadClass(var1, var2); //到这里来，所以实际上应用加载器这个方法也执行了，只是相当于还没有执行，执行了两次loadClass，一个子（基本没有什么操作），一个父（ClassLoader），即并不是所有加载器都加载父（ClassLoader的）的
            }
        }

/*
譬如有A和B两个对象，他们都互相引用，除此之外都没有任何对外的引用，那么理论上A和B都可以被作为垃
圾回收掉，但实际如果采用引用计数算法，则A、B的引用计数都是1（因为A或者B只被对方引用，也就是1），并不满足被回收的条件，如果A和B之间的引用一直存在，那么就永远无法被回收了
*/

package com.lagou.lagou1;

/**
 *
 */
public class App {
    public static void main(String[] args) {
        Test object1 = new Test();
        Test object2 = new Test();
        object1.object = object2;
        object2.object = object1;
        object1 = null;
        object2 = null;
        
    }
}


class Test {
    public Test object = null;
}

//Object类里面的（jdk8版本）
protected void finalize() throws Throwable {
    }

package com.lagou.lagou1;

/**
 * 此代码演示了两点：
 * 1.对象可以在被GC时自我拯救。
 * 2.这种自救的机会只有一次， 因为一个对象的finalize()方法最多只会被系统自动调用一次
 */
public class FinalizeEscapeGC {
    public static FinalizeEscapeGC SAVE_HOOK = null;

    public void isAlive() {
        System.out.println("yes, i am still alive :)");
    }

    @Override
    protected void finalize() throws Throwable {
        super.finalize();
        //如果这里操作等待，那么第一个gc等待，第二个gc不会，也就是说gc是不同的，或者说会加gc线程，或者是多线程（可能也会加）
        System.out.println("finalize method executed!");
        FinalizeEscapeGC.SAVE_HOOK = this;
    }

    public static void main(String[] args) throws Throwable {
        SAVE_HOOK = new FinalizeEscapeGC();
        //对象第一次成功拯救自己
        SAVE_HOOK = null;
        System.gc(); //执行多次第二次以及后面的次数一般不会激活了（除非他操作完毕了），即基本不做任何操作，自动反应（gc）需要关闭虚拟机，所以这里手动，来使得触发（gc是操作一次的，就如前面操作新生代gc，可以经历多次一样，当前，也就是相当于当前代码以及上面代码操作后的结果，可能会加上后面代码，因为回收需要时间，所以这里加上等待）
        // 因为Finalizer方法优先级很低， 暂停0.5秒， 以等待它，一般所有的gc都会去操作是否满足，自动gc除外
        //你可以等待50000，而不手动gc，会发现，没有操作gc，因为自动gc需要关闭虚拟机时触发的自动回收的，总不能虚拟机关闭，里面的内容直接不管了吧（需要优雅的关闭，也就是自动gc），注意：手动gc也需要时间（STW），但是经过测试，会发现，必须加上下面的等待，也就是说，STW在Finalizer方法之前就不会等待了（那么主线程会继续执行），所以为了让他执行完，才会操作0.5秒等待
        Thread.sleep(500);
        if (SAVE_HOOK != null) {
            SAVE_HOOK.isAlive();
        } else {
            System.out.println("no, i am dead :(");
        }
        //下面这段代码与上面的完全相同，但是这次自救却失败了
        SAVE_HOOK = null;
        System.gc();
        // 因为Finalizer方法优先级很低， 暂停0.5秒， 以等待它
        Thread.sleep(500); //对应的方法finalize只会操作一次，也就是说会有其他标记的（比如地址没有改变），即缓存来进行操作该一次恢复，总不能给你无限的复活吧，因为你执行该方法反正会复活，那么自然就不会回收了，所以给出限制（也就是复活一次）
        //当然，如果没有，自然不会链接，所以根据这里的解释，也的确说明了"没有覆盖finalize()方法，或者finalize()方法已经被虚拟机调用过"，那么满足回收，当然就算方法存在，如果没有建立连接，那么也满足回收（第二次进行标记）
        if (SAVE_HOOK != null) {
            SAVE_HOOK.isAlive();
        } else {
            System.out.println("no, i am dead :(");
        }
    }

}

/*
打印结果：
finalize method executed!
yes, i am still alive :)
no, i am dead :(
 */

package heihei;

import java.util.ArrayList;

/**
 * -XX:+PrintCommandLineFlags 查看程序使用的默认JVM参数
 * -XX:+UseSerialGC 设置垃圾回收器为年轻代垃圾回收器使用serial，且设置了老年代使用serial Old，设置了两个哦
 */
public class test {
    public static void main(String[] args) {
        ArrayList<byte[]> list = new ArrayList<byte[]>();
        while (true){
            byte[] b = new byte[1024];
            list.add(b);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

/*
-XX:+PrintCommandLineFlags设置好后，仍然是之前的VM options的操作，可以看到对应的参数的，比如我的结果就是：
-XX:InitialHeapSize=131782592 -XX:MaxHeapSize=2108521472 -XX:+PrintCommandLineFlags -XX:+UseCompressedClassPointers -XX:+UseCompressedOops -XX:-UseLargePagesIndividualAllocation -XX:+UseParallelGC 
-XX:MaxHeapSize相当于-Xmx的，他们可以同时设置，并且谁在后面那么谁进行覆盖，比如-Xmx5m -Xmx200m，不会报错，且结果是200m，而-Xmx5m -XX:MaxHeapSize=200m，结果也是200m，他们单位默认字节，可以是k，m，但是其他乱写的单位不行的，比如jjj，那肯定不行，一般是规定有限的，他一般是m，k，和不写的字节（没有规定他的单位，那么只能不写了）

可以看到-XX:+UseParallelGC，就是使用的gc，看看项目版本，我这里是jdk8，由于JDK8中默认使用组合是：Parallel Scavenge GC，ParallelOld GC，那么他可能代表就是这两个（一般是的，其中老年代那里会说明），一般是默认的（虽然是UseParallelGC），不同jdk版本可能默认的是不同的，可以自己进行测试

我们继续设置参数-XX:+UseSerialGC（补充即可），结果如下：
-XX:InitialHeapSize=131782592 -XX:MaxHeapSize=2108521472 -XX:+PrintCommandLineFlags -XX:+UseCompressedClassPointers -XX:+UseCompressedOops -XX:-UseLargePagesIndividualAllocation -XX:+UseSerialGC 
变成-XX:+UseSerialGC了，可能代表就是前面说明的"置垃圾回收器为年轻代垃圾回收器使用serial，且老年代使用serial Old"，一次设置两个
*/

package heihei;

import java.util.ArrayList;

/**
 * -XX:+UseParNewGC 并行垃圾回收器，收集新生代，这里包括老年代，即Serial Old，也可以进行改变老年代，即使用下面一种
 * -XX:+UseConcMarkSweepGC CMS的，并行垃圾回收器，用来改变老年代的，使得对应Serial Old加上CMS，但要注意，他们一般并不是互相覆盖的，也就是说，只要你写了我就会操作覆盖，否则不会
 */
public class test1 {
    public static void main(String[] args) {
        ArrayList<byte[]> list = new ArrayList<byte[]>();
        while (true){
            byte[] b = new byte[1024];
            list.add(b);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    /*
    使用前面的设置，操作-XX:+UseParNewGC，将之前的-XX:+UseSerialGC进行替换，结果如下：
    -XX:InitialHeapSize=131782592 -XX:MaxHeapSize=2108521472 -XX:+PrintCommandLineFlags -XX:+UseCompressedClassPointers -XX:+UseCompressedOops -XX:-UseLargePagesIndividualAllocation -XX:+UseParNewGC 
    变成了-XX:+UseParNewGC，注意：记得是替换，不要补充，否则会报错的，只能识别一个设置（包括老年），多余的设置会报错（认为有标记表示已经设置了）
    可以补充这个-XX:+UseConcMarkSweepGC，不属于上面的标记，因为是改变老年代的，结果如下：
    -XX:InitialHeapSize=131782592 -XX:MaxHeapSize=2108521472 -XX:MaxNewSize=697933824 -XX:MaxTenuringThreshold=6 -XX:OldPLABSize=16 -XX:+PrintCommandLineFlags -XX:+UseCompressedClassPointers -XX:+UseCompressedOops -XX:+UseConcMarkSweepGC -XX:-UseLargePagesIndividualAllocation -XX:+UseParNewGC 
    多出了其他信息，和-XX:+UseConcMarkSweepGC，其他信息了解即可
     */
}

package heihei;

import java.util.ArrayList;

/** +是设置格式，可能是固定的，注意即可，通过我的观察，基本上操作值的，不会有+，否则会有，而实际上+代表添加设置，那么你在设置时，变成-，可能就是删除改设置了，通过测试，我们知道有个默认的-XX:+UseParallelGC，当我们设置减时，他还存在，说明，默认的是最后操作的，覆盖他，所以下面的-XX:+UseParallelGC是否设置反正被覆盖，而正是因为一开始没有，那么操作减没有什么作用，因为反正是没有的（虽然这里有覆盖，其他反正也是没有，只是没有这个默认覆盖而已），所以我们只能使用jinfo来减了
 * -XX:+UseParallelGC 使用parallel scavenge 垃圾回收器，也包括Serial Old 
 * -XX:MaxGCPauseMillis 设置暂停时间，不推荐
 * -XX:+UseAdaptiveSizePolicy 自适应配置策略（Eden，Suvisor区的比例，晋升老年代的对象年龄等）
 * -XX:ParllGCThreads 设置年轻代线程数
 */
public class test2 {
    public static void main(String[] args) {
        ArrayList<byte[]> list = new ArrayList<byte[]>();
        while (true) {
            byte[] b = new byte[1024];
            list.add(b);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

/*
使用-XX:+PrintCommandLineFlags -XX:+UseParallelGC，结果如下：
-XX:InitialHeapSize=131782592 -XX:MaxHeapSize=2108521472 -XX:+PrintCommandLineFlags -XX:+UseCompressedClassPointers -XX:+UseCompressedOops -XX:-UseLargePagesIndividualAllocation -XX:+UseParallelGC 
-XX:+UseParallelGC 没有改变，默认的也是这个，也就是说，无论你是否加上结果都一样（标记操作了，并使得覆盖了）
我们继续补充：-XX:MaxGCPauseMillis=100，结果：
-XX:InitialHeapSize=131782592 -XX:MaxGCPauseMillis=100 -XX:MaxHeapSize=2108521472 -XX:+PrintCommandLineFlags -XX:+UseCompressedClassPointers -XX:+UseCompressedOops -XX:-UseLargePagesIndividualAllocation -XX:+UseParallelGC 
多出了-XX:MaxGCPauseMillis=100
继续补充：-XX:+UseAdaptiveSizePolicy，结果：
-XX:InitialHeapSize=131782592 -XX:MaxGCPauseMillis=100 -XX:MaxHeapSize=2108521472 -XX:+PrintCommandLineFlags -XX:+UseAdaptiveSizePolicy -XX:+UseCompressedClassPointers -XX:+UseCompressedOops -XX:-UseLargePagesIndividualAllocation -XX:+UseParallelGC 
多出了-XX:+UseAdaptiveSizePolicy
我们也可以在控制台打印jps，根据当前程序运行的进程号操作如下：
jinfo -flag UseAdaptiveSizePolicy 进程号，如果打印出来-XX:+UseAdaptiveSizePolicy（虽然也有时认为是值的意思，比如将UseAdaptiveSizePolicy替换成MetaspaceSize就是对应的值，在前面测试过了）
了，说明使用了自适应配置策略，如果是-XX:-UseAdaptiveSizePolicy说明没有使用，注意，在某些jdk版本下，可能默认是使用的虽然在运行时的打印（不是控制台）没有出现
继续补充：XX:ParllGCThreads（在不同jdk版本中，可能-会去除，但一般不会），可能会报错，所以结果就不给出了
*/

package heihei;

import java.util.ArrayList;

/**
 * -XX:+UseParallelOldGC：指定使用Parallel Old收集器，即改变对应的老年代
 */
public class test3 {
    public static void main(String[] args) {
        ArrayList<byte[]> list = new ArrayList<byte[]>();
        while (true) {
            byte[] b = new byte[1024];
            list.add(b);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
    /*
    设置加上-XX:+PrintCommandLineFlags -XX:+UseParallelOldGC，结果如下：
    -XX:InitialHeapSize=131782592 -XX:MaxHeapSize=2108521472 -XX:+PrintCommandLineFlags -XX:+UseCompressedClassPointers -XX:+UseCompressedOops -XX:-UseLargePagesIndividualAllocation -XX:+UseParallelOldGC 
    变成了-XX:+UseParallelOldGC 
     */
}

var G = objE.fieldG; 
objE.fieldG = null;  // 灰色E 断开引用 白色G 
objD.fieldG = G;  // 黑色D 引用 白色G

var G = objE.fieldG; // 1.读
objE.fieldG = null;  // 2.写
objD.fieldG = G;     // 3.写

参数/默认值	含义
-XX:+UseG1GC	使用 G1 垃圾收集器（他直接操作，就他一人，没有什么新老）
-XX:MaxGCPauseMillis=200	设置期望达到的最大GC停顿时间指标（JVM会尽力实现，但不保证达到）
-XX:InitiatingHeapOccupancyPercent=45（代表45%）	mixed gc中也有一个阈值参数，当老年代大小占整个堆大小百分比达到该阈值时，会触发一次mixed gc，默认值为 45
-XX:NewRatio=2	新生代与老生代(new/old generation)的大小比例(Ratio)，默认值为 2
-XX:SurvivorRatio=8	eden/survivor 空间大小的比例(Ratio)，默认值为 8
-XX:MaxTenuringThreshold=15	提升年老代的最大临界值(tenuring threshold)，默认值为 15
-XX:ParallelGCThreads=n（n是未知数，不能加，否则报错，可以设置为4）	设置垃圾收集器在并行阶段使用的线程数，默认值随JVM运行的平台不同而不同
-XX:ConcGCThreads=n（n是未知数，不能加，否则报错，可以设置为4）	并发垃圾收集器使用的线程数量，默认值随JVM运行的平台不同而不同
-XX:G1ReservePercent=10	设置堆内存保留为假天花板的总量，以降低提升失败的可能性，默认值是 10
-XX:G1HeapRegionSize=1m（默认字节单位，可以加单位来改变，如k，与前面的单位一样的可以加哦，也就是有单位使用单位的，否则默认字节单位，虽然有些地方说明不能加单位）	使用G1时Java堆会被分为大小统一的的区(region)，此参数可以指定每个heap（堆）区的大小，默认值将根据 heap size 算出最优解，最小值为1Mb, 最大值为 32Mb

jps -l //输出jar包路径（存在的话，或者说是直接操作jar里面的class，而不是直接存在的class），类全名
jps -m //输出main参数
jps -v //输出JVM参数

package coo;

/**
 *
 */
public class Demo1_Jps {
    public static void main(String[] args) throws InterruptedException {
        Thread.sleep(1000000);
    }
}

package coo;

/**
 *
 */
public class Demo1_Jps {
    public static void main(String[] args) throws InterruptedException {
        System.out.println(args.length); //为0
        for (int i = 0; i < args.length; i++) {
            System.out.println(args[i] + "第" + i + "个");
        }
        Thread.sleep(1000000);
    }
}

jinfo -flag PrintGCDetails 10000 //查看是否生效（虽然有些是认为值的意思，比如MetaspaceSize ）
jinfo -flag +PrintGCDetails 10000 //使得他生效，一般代表前面出现+就是生效，如-XX:+PrintGCDetails，而-XX:PrintGCDetails就是没有生效
//我们继续查看是否生效，若报错，那么一般是jdk版本的原因，可能他不准改变了，你可以修改成jdk8来进行测试，那么一般不会报错，然后查看的结果如果变成+了，说明操作成功
//当然，并不是所有的设置都可以改变，无论jdk版本，比如UseParallelGC就是这样，也就是gc操作，一般不能被修改，因为已经确定gc了，可能有操作处初始化了，那么修改有点不好，可能以后会允许
//其他的自己测试，这里是因为有版本问题，所以提一下了
//并且我们可以发现，无论是+-的还是设置值的，都可以进行操作，即PrintGCDetails替换前面说明的任何设置，除了本质设置，如Xmx等等

package coo;

import java.io.IOException;

/**
 *
 */
public class tets2 {
    public static void main(String[] args) throws IOException {
        //system.in.read()方法的作用是从键盘读出一个字符，然后返回它的Unicode码，他本身需要等待你输入，当你回车时结束等待（按下Enter结束输入）
        int read = System.in.read();
        System.out.println(read);
        while (true) {
            int read1 = System.in.read();
            System.out.println(read1);
            break;
        }

        //当你输入1时，按下回车，注意，重中之重，按下回车这个也算，也就是说，上面会打印两个值，结果就是49（1），10（回车的）
        //但是还要注意，只要你再次的执行System.in.read();，他又会需要你阻塞，那么总值可能是这样的
        //首先，我们将回车看成p，输入保留的地方看成[]，一开始是空的，当我们输入1时，回车结束，那么保留的地方是[1，p]（这里认为赋值时给Unicode码值）
        //那么他首先会按照顺序来给，那么上面的read就是1的Unicode码值，那么保留的就是[p]，后续又会进行输入1，那么保留的值是[p，1，p]，根据顺序，将p给read1
        //所以上面打印p的Unicode码值，那么结果也就是49和10了

    }
}

//大多数情况下，我们可以只用System.in.read()来进行阻塞，而回车就代表解除阻塞，即大多数情况下，我们是这样使用了，而不操作返回值

package coo;

import java.io.IOException;

/**
 * -verbose:gc，一般是在控制台输出GC情况，然而-XX:+PrintGCDetails包括了-verbose:gc，所以-verbose:gc可以不写
 * 记得设置如下参数：
 * jvm参数：-Xms20m -Xmx20m -Xmn10m -XX:+UseSerialGC -XX:+PrintGCDetails -verbose:gc
 */
public class test {
    public static void main(String[] args) throws IOException {
        final int _1m = 1024*1024;
        byte[] b1 = new byte[2 * _1m];
        System.out.println("创建b1...");
        System.in.read();

        byte[] b2 = new byte[2 * _1m];
        System.out.println("创建b2...");
        System.in.read();

        byte[] b3 = new byte[2 * _1m];
        System.out.println("创建b3...");
        System.in.read();

    }
}

package coo;

/**
 *
 */
public class test3 {
    public static void main(String[] args) {
        System.out.println(1);
        while (true);//相当于无限循环，即while(true){}，实际上我们也可以将他称为阻塞
    }
}

package coo;

/**
 *
 */
public class DeadLock {
    private static Object obj1 = new Object();
    private static Object obj2 = new Object();

    public static void main(String[] args) {
        new Thread(new Thread1()).start();
        new Thread(new Thread2()).start();
    }

    private static class Thread1 implements Runnable {
        public void run() {
            synchronized (obj1) {
                System.out.println("Thread1 拿到了 obj1 的锁！");
                try {// 停顿2秒的意义在于，让Thread2线程拿到obj2的锁
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (obj2) {
                    System.out.println("Thread1 拿到了 obj2 的锁！");
                }
            }
        }
    }

    private static class Thread2 implements Runnable {
        public void run() {
            synchronized (obj2) {
                System.out.println("Thread2 拿到了 obj2 的锁！");
                try {// 停顿2秒的意义在于，让Thread1线程拿到obj1的锁
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (obj1) {
                    System.out.println("Thread2 拿到了 obj1 的锁！");
                }
            }
        }
    }
}

//注意：像命令什么的，为了保证博客的显示，一般需要<dump-options>变成< dump-options>才可，自己注意一下就行

package test;

import java.util.ArrayList;
import java.util.List;

/**
 *
 */
public class JConsoleDemo {
    static class OOMObject {
        public byte[] placeholder = new byte[8 * 1024];
    }

    public static void fillHeap(int num) throws InterruptedException {
        List<OOMObject> list = new ArrayList<OOMObject>();
        for (int i = 0; i < num; i++) {
            Thread.sleep(200);
            list.add(new OOMObject());
        }
        System.gc();
    }

    public static void main(String[] args) throws Exception {
        fillHeap(1000000);
        System.gc(); //注意：方法结束后，我们知道他里面的内容会清除，也就是说，上面的list相当于自动的设置为null（或者说他直接没有，即销毁），那么这个gc会导致都进行清理，所以要考虑方法执行完毕哦，这是重中之重，在前面可能并没有具体说明过，所以我们有时候在前面也说过，虚拟机结束操作自动的gc，与这里实际上是类似的
    }
}
 //设置：-Xms100m -Xmx100m -XX:+UseSerialGC

package test;

import java.io.BufferedReader;
import java.io.InputStreamReader;

/**
 *
 */
public class test4 {
    /**
     * 线程死循环演示
     */
    public static void createBusyThread() {
        Thread thread = new Thread(new Runnable() {
            public void run() {
                while (true) ;
            }
        }, "testBusyThread");
        System.out.println("启动testBusyThread 线程完毕..");
        thread.start();
    }

    /**
     * 线程锁等待演示
     */
    public static void createLockThread(final Object lock) { //局部变量是可以设置为final的
        Thread thread = new Thread(new Runnable() {
            public void run() {
                synchronized (lock) {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "testLockThread");
        thread.start();
        System.out.println("启动testLockThread 线程完毕..");
    }

    public static void main(String[] args) throws Exception {
        System.out.println("main 线程..");
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("redLine阻塞");
        br.readLine();
        createBusyThread();
        System.out.println("redLine阻塞");
        br.readLine();
        Object obj = new Object();
        createLockThread(obj);
        System.out.println("main 线程结束..");
    }
}

package test;

/**
 *
 */
public class test5 {
    /**
     * 线程死锁等待演示
     */
    static class SynAddRunalbe implements Runnable {
        int a, b;

        public SynAddRunalbe(int a, int b) {
            this.a = a;
            this.b = b;
        }

        public void run() {
            synchronized (Integer.valueOf(a)) {
                synchronized (Integer.valueOf(b)) {
                    System.out.println(a + b);
                }
            }
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(new SynAddRunalbe(1, 2)).start();
            new Thread(new SynAddRunalbe(2, 1)).start();
        }
    }
}

package test;

import java.io.IOException;
import java.util.ArrayList;

/**
 *
 */
public class test6 {
    public static void main(String[] args) throws IOException, InterruptedException {
        System.in.read();
        fun();
        System.in.read();
    }

    private static void fun() throws InterruptedException {
        ArrayList<Capacity> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            Thread.sleep(400);
            list.add(new Capacity());
        }
    }


}

class Capacity {
    private byte[] big = new byte[8 * 1024 * 1024]; //8m
}

参数	说明
-XX:+PrintGC	打印简单GC日志，类似：-verbose:gc
-XX:+PrintGCDetails	打印GC详细信息
-XX:+PrintGCTimeStamps	输出GC的时间戳（以基准时间的形式）
-XX:+PrintGCDateStamps	输出GC的时间戳（以日期的形式）
-XX:+PrintHeapAtGC	在进行GC的前后打印出堆的信息
-Xloggc:…/logs/gc.log	指定输出路径收集日志到日志文件

-Xms28m
-Xmx28m
//开启记录GC日志详细信息（包括GC类型、各个操作使用的时间），并且在程序运行结束打印出JVM的内存占用情况
-XX:+PrintGCDetails
-XX:+PrintGCDateStamps
//这个还可以开启滚动的生成日志，即滚动的方式来显示信息
-XX:+UseGCLogFileRotation
-Xloggc:E:/logs/gc.log //指定输出路径收集日志到日志文件（包括很多日志，一般比打印的控制台（不是命令的）要多，因为有隐藏不显示的日志信息，要不然，为什么有时候需要log4j.properties日志的配置呢）

参数	描述
UseSerialGC	虚拟机在运行在 Client 模式下的默认值，打开此开关后，使用 Serial+Serial Old 收集器组合进行内存回收
UseParNewGC	使用 ParNew + Serial Old 收集器组合进行内存回收
UseConcMarkSweepGC	使用 ParNew + CMS + Serial Old 的收集器组合尽心内存回收，当 CMS 出现 Concurrent Mode Failure 失败后会使用 Serial Old 作为备用收集器
UseParallelOldGC	使用 Parallel Scavenge + Parallel Old 的收集器组合
UseParallelGC	使用 Parallel Scavenge + Serial Old （PS MarkSweep）的收集器组合
SurvivorRatio	新生代中 Eden 和任何一个 Survivor 区域的容量比值，默认为 8
PretenureSizeThreshold	直接晋升到老年代对象的大小，单位是Byte
UseAdaptiveSizePolicy	动态调整 Java 堆中各区域的大小以及进入老年代的年龄
ParallelGCThreads	设置并行 GC 时进行内存回收的线程数
GCTimeRatio	GC 时间占总时间的比率，默认值为99，只在 Parallel Scavenge 收集器的时候生效
MaxGCPauseMillis	设置 GC 最大的停顿时间，只在 Parallel Scavenge 收集器的时候生效
CMSInitiatingOccupancyFraction	设置 CMS 收集器在老年代空间被使用多少后触发垃圾收集，默认是 68%，仅在 CMS 收集器上生效
CMSFullGCsBeforeCompaction	设置 CMS 收集器在进行多少次垃圾回收之后启动一次内存碎片整理
UseG1GC	使用 G1 (Garbage First) 垃圾收集器
MaxGCPauseMillis	设置最大GC停顿时间（GC pause time）指标（target），这是一个软性指标(so会尽量去达成这个目标
G1HeapRegionSize	使用G1时Java堆会被分为大小统一的的区(region)。此参数可以指定每个heap区的大小，默认值将根据 heap size 算出最优解，最小值为 1Mb，最大值为 32Mb

GC (Allocation Failure) [PSYoungGen: 6146K->904K(9216K)] 6146K->5008K(19456K), 0.0038730secs] [Times: user=0.08 sys=0.00, real=0.00 secs]

[a(b)[c:d->e(f), g secs] h->i(j), k secs] [Times: user:l sys=m, real=n secs] //g secs好像没有（因为是PSYoungGen，他一边好像不显示，并非是完美的哦，任何操作都会有疏漏，要不然为什么说安全是99%，而不会是100%），但图片有
/*
a: GC 或者是 Full GC 
b: 用来说明发生这次 GC 的原因 
c: 表示发生GC的区域，这里表示是新生代发生了GC，上面那个例子是因为在新生代中内存不够给新对象分配了，然后触发了 GC，前面的PS代表Parallel Scavenge的gc（默认的，通常不同版本是不同的默认，jdk8默认的是这个，在前面的"垃圾收集器的组合关系"后面就有说明）
d: GC 之前该区域已使用的容量 
e: GC 之后该区域已使用的容量 
f: 该内存区域的总容量 
g: 表示该区域这次 GC 使用的时间 
h: 表示 GC 前整个堆的已使用容量 
i: 表示 GC 后整个堆的已使用容量 
j: 表示 Java 堆的总容量 
k: 表示 Java堆 这次 GC 使用的时间 
l: 代表用户态消耗的 CPU 时间 
m: 代表内核态消耗的 CPU 时间 
n: 整个 GC 事件从开始到结束的墙钟时间（Wall Clock Time） 
*/

-Xms20M -Xmx20M -Xmn10M -XX:+UseParNewGC -XX:+PrintGCDetails -XX:SurvivorRatio=8 -XX:+PrintCommandLineFlags
    //对应老年代使用默认的，所以这里不是使用ParNew+Serial Old

package test;

/**
 *
 */
public class test11 {
    private static final int _1MB = 1024 * 1024;

    public static void testAllocation() {
        byte[] allocation1, allocation2, allocation3, allocation4;
        allocation1 = new byte[2 * _1MB];
        allocation2 = new byte[2 * _1MB];
        allocation3 = new byte[2 * _1MB];
        allocation4 = new byte[4 * _1MB]; //出现一次 Minor GC
    }

    public static void main(String[] args) {
        testAllocation();
    }
}

-Xms20M -Xmx20M -Xmn10M -XX:+UseParallelGC -XX:+PrintGCDetails -XX:SurvivorRatio=8

package test;

/**
 *
 */
public class test22 {
    private static final int _1MB = 1024 * 1024;

    public static void testAllocation() {
        byte[] allocation1, allocation2, allocation3, allocation4;
        allocation1 = new byte[2 * _1MB];
        allocation2 = new byte[2 * _1MB];
        allocation3 = new byte[2 * _1MB];
        allocation4 = new byte[4 * _1MB]; //出现一次 Minor GC
    }

    public static void main(String[] args) {
        testAllocation();
    }
}

-verbose:gc -Xms20M -Xmx20M -Xmn10M -XX:+UseParNewGC -XX:+PrintGCDetails -XX:PretenureSizeThreshold=3145728 
    //1024*1024*3=3145728 ，他单位是字节，默认的，可以是k，m

package test;

/**
 *
 */
public class test33 {
    private static final int _1MB = 1024 * 1024;

    public static void testPreteureSizeThreshold() {
        byte[] allocation;
        allocation = new byte[4 * _1MB];
    }

    public static void main(String[] args) {
        testPreteureSizeThreshold();
    }


}

package test;

import java.util.ArrayList;

/** 注意：记得存在logs这个目录，否则会提示你的
 * -Xms100M -Xmx100M -XX:SurvivorRatio=8  -XX:+PrintGCDetails -Xloggc:D://logs/gc.log
 */
public class test44 {
    private static final int _1MB = 1024 * 1024;

    public static void main(String[] args) {
        ArrayList<byte[]> list = new ArrayList<byte[]>();
        for (int i = 0; i < 500; i++) {
            byte[] arr = new byte[1024 * 1024];
            list.add(arr);
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

tar -xvf apache-tomcat-8.5.85.tar.gz #当然，随着时间的推移，该名称可能有所改变，所以这里记得写上你自己的文件
cd apache-tomcat-8.5.85/conf/
#修改配置文件，配置tomcat管理用户
vim tomcat-users.xml #如果没有vim，那么vi一般都会有，这是基本的，否则怎么操作文件呢（除非人为干预）
#写入如下消息
<role rolename="manager"/>
<role rolename="manager-gui"/>
<role rolename="admin"/>
<role rolename="admin-gui"/>
<user username="tomcat" password="tomcat" roles="admin-gui,admin,manager-gui,manager"/>

:wq退出

#注意：在Linux中（windows一般不会，即无论是7还是8都不用下面的配置操作，照样可以登录，这可能是文件系统的问题，因为我在windows中确不用设置，所以我才说应该是文件系统的原因），如果是tomcat7，配置了tomcat用户就可以登录了，但是tomcat8不行，需要修改一个配置文件，否则访问会报403
#回到cd apache-tomcat-8.5.85（相对的）
vim  webapps/manager/META-INF/context.xml

<Context antiResourceLocking="false" privileged="true" >
  <CookieProcessor className="org.apache.tomcat.util.http.Rfc6265CookieProcessor"
                   sameSiteCookies="strict" />
<!--  <Valve className="org.apache.catalina.valves.RemoteAddrValve"
         allow="127\.\d+\.\d+\.\d+|::1|0:0:0:0:0:0:0:1" /> -->
  <Manager sessionAttributeValueClassNameFilter="java\.lang\.(?:Boolean|Integer|Long|Number|String)|org\.apache\.catalina\.filters\.CsrfPreventionFilter\$LruCache(?:\$1)?|java\.util\.(?:Linked)?HashMap"/>
</Context>

#我们注释掉上面的移动配置就行

<Connector port="8009" protocol="AJP/1.3" redirectPort="8443" /> #一般来说，基本都是注释掉的，即禁用的

<!--将注释打开，这个<Executor name="tomcatThreadPool"是主要的打开（但确需要使用），后面基本有默认的-->
<Executor name="tomcatThreadPool" namePrefix="catalina‐exec‐" maxThreads="500" 
minSpareThreads="50" prestartminSpareThreads="true" maxQueueSize="100"/>
<!--
参数说明：
maxThreads：最大并发数，默认设置200，一般建议在500 ~ 1000，根据硬件设施和业务来判断
minSpareThreads：Tomcat初始化时创建的线程数，默认设置25 
prestartminSpareThreads：在Tomcat初始化的时候就初始化minSpareThreads 的参数值，如果不等于 true，minSpareThreads 的值可能就没啥效果了，而是操作默认，当然，可能其他版本的tomcat不需要，但最好写上
maxQueueSize，最大的等待队列数，超过则拒绝请求
-->
 <!-- A "Connector" represents an endpoint by which requests are received
         and responses are returned. Documentation at :
         Java HTTP Connector: /docs/config/http.html
         Java AJP Connector: /docs/config/ajp.html
         APR (HTTP/AJP) Connector: /docs/apr.html
         Define a non-SSL/TLS HTTP/1.1 Connector on port 8080
 -->
    <Connector port="8080" executor="tomcatThreadPool"  protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />
    <!-- A "Connector" using the shared thread pool-->

   <!-- 最大等待数为100，maxQueueSize="100"-->
<Executor name="tomcatThreadPool" namePrefix="catalina‐exec‐" maxThreads="500" 
minSpareThreads="100"
prestartminSpareThreads="true" maxQueueSize="100"/>

<Connector executor="tomcatThreadPool" port="8080" 
protocol="org.apache.coyote.http11.Http11Nio2Protocol"
connectionTimeout="20000" redirectPort="8443" />

#首先通过底行模式，输入/JAVA_OPTS查找，一般是JAVA_OPTS="$JAVA_OPTS $JSSE_OPTS"地方，然后在JAVA_OPTS="$JAVA_OPTS -Djava.protocol.handler.pkgs=org.apache.catalina.webresources"后面补充如下
JAVA_OPTS="-XX:+UseParallelGC -XX:+UseParallelOldGC -Xms64m -Xmx512m -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -XX:+PrintHeapAtGC -Xloggc:../logs/gc.log"

#然后注释掉：JAVA_OPTS="$JAVA_OPTS -Djava.protocol.handler.pkgs=org.apache.catalina.webresources"

#你要知道，这不是配置，而是命令的执行（sh后缀），所以先后顺序是重要的

#注意：上面的一些配置可能需要删除，如-XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -XX:+PrintHeapAtGC，否则可能启动不了（jdk版本问题，前面说明过了），直接启动可能看不到日志，可以这样的启动./startup.sh && tail -f ../logs/catalina.out，就能看到类似的在idea中执行的对应可以会出现（jdk11）的错误显示了

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java：104-JVM优化

我们可以选择在idea中查看对应的class文件：但是要注意：随着idea或者说jdk版本的不同，可能并不会出现这些东西或者少些或者有些不同，所以这里以上面的说明为主即可（我修改并整理的）比如我这里就是这样：Java 虚拟机采用基于栈的架构，其指令由操作码和操作数组成，这些字节码指令，就叫作 opcode，其中，getstatic、ldc、invokevirtual、return 等，就是 opcode，可以看到是比较容易理解的，因为根据后面的说明就是一个完整的System.out.print
复制链接

扫一扫

Java：104-JVM优化

JVM优化

为什么要学习JVM优化：

1：深入地理解 Java 这门语言

2：更好的解决线上排查问题

JVM回顾（对于一些概念来说，可以大致的过一遍）：

什么是JVM：

JVM是Java Virtual Machine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算 机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的，一般用来操作java的

主流虚拟机：

JVM与操作系统：

为什么要在程序和操作系统中间添加一个JVM：

而 Java 跨平台的意义在于一次编译，处处运行，能够做到这一点 JVM 功不可没，比如我们在 Maven 仓库下载同一 版本的 jar 包就可以到处运行，不需要在每个平台上再编译一次

现在的一些 JVM 的扩展语言，比如 Clojure、JRuby、Groovy 等，编译到最后都是 .class 文件，Java 语言的维护 者，只需要控制好 JVM 这个解析器，就可以将这些扩展语言无缝的运行在 JVM 之上了

应用程序、JVM、操作系统之间的关系：

我们用一句话概括 JVM 与操作系统之间的关系：JVM 上承开发语言，下接操作系统，它的中间接口就是字节码

JVM、JRE、JDK 的关系：

JVM 是 Java 程序能够运行的核心，但是需要注意，JVM 自己什么也干不了，你需要给它提供生产原料（.class 文 件）

类库一般也有第三方的（第三方：代表其他地方的说明，一般我们用第三方来表示而已，你也可以称为第二方，比如jar包）

Java虚拟机规范和 Java 语言规范的关系：

如果 .class 文件的规格是不变的，这两部分是可以独立进行优化的，但 Java 也会偶尔扩充一下 .class 文件的格式， 增加一些字节码指令，以便支持更多的特性

我们可以把 Java 虚拟机可以看作是一台抽象的计算机，它有自己的指令集以及各种运行时内存区域（若学习过《计算 机组成结构（原理）》或者相关的书籍，那么可以发现有类似的情况）

最后，我们简单看一下一个 Java 程序的执行过程，它到底是如何运行起来的：

这里的 Java 程序是文本格式的，比如下面这段 HelloWorld.java，它遵循的就是 Java 语言规范，其中，我们调用了System.out 等模块，也就是 JRE 里提供的类库

我们可以选择在idea中查看对应的class文件：

难道class文件长这样吗，答：并不是，他只是idea给我们总结的而已，实际上并不是这样（你也可以去磁盘中打开就知道了。但是一般是乱码），而若要真正的看到对应的文件信息，需要如下操作：

使用 JDK 的工具 javac 进行编译后，会产生 HelloWorld 的字节码，我们一直在说 Java 字节码是沟通 JVM 与 Java 程序的桥梁，下面使用 javap 来稍微看一下字节码到底长什么样子

点击如下：

但是要注意：随着idea或者说jdk版本的不同，可能并不会出现这些东西或者少些或者有些不同，所以这里以上面的说明为主即可（我修改并整理的）

比如我这里就是这样：

java虚拟机的内存管理：

JVM整体架构：

根据 JVM 规范，JVM 内存共分为虚拟机栈、堆、方法区、程序计数器、本地方法栈五个部分

JVM分为五大模块： 类装载器子系统，运行时数据区，执行引擎，本地方法接口 和 垃圾收集模块

JVM运行时内存（也就是主要说明运行时数据区）：

Java 虚拟机有自动内存管理机制，如果出现面的问题，排查错误就必须要了解虚拟机是怎样使用内存的

Java7和Java8内存结构的不同主要体现在方法区的实现：

方法区是java虚拟机规范中定义的一种概念上的区域，不同的厂商可以对虚拟机进行不同的实现

我们通常使用的Java SE都是由Sun JDK和OpenJDK所提供，这也是应用最广泛的版本，而该版本使用的VM就是HotSpot VM，通常情况下，我们所讲的java虚拟机指的就是HotSpot的版本

JDK7 内存结构：

JDK8 的内存结构（主要说明这个）：

针对JDK8虚拟机内存详解（以后也是这样，一般jdk8之后的通常不会改变，如果改变了，可以去网上找资料，但一般以jdk8为主）：

JDK7和JDK8变化小结（上面说明的都是概念，真正的存放位置看如下，特别是堆和方法区，在jdk8以前，是属于一个地方（下面框框），看下图就知道了）：

对于Java8，HotSpots取消了永久代（也就是方法区那里，这就是一个名称而已，一般方法区看成永久代，所以你可以认为，方法区就是永久代），那么是不是就没有方法区了呢？

当然不是，方法区只是一个规范，只不过它的实现变了，即由别人实现了

方法区Java8之后的变化：

移除了永久代（PermGen），替换为元空间（Metaspace）

永久代中的class metadata（类元信息）转移到了native memory（本地内存，而不是虚拟机）

永久代中的interned Strings（字符串常量池） 和 class static variables（类静态变量）转移到了Java heap（堆）

永久代参数（PermSize MaxPermSize）-> 元空间参数（MetaspaceSize MaxMetaspaceSize）

Java8为什么要将永久代替换成Metaspace？

字符串存在永久代中，容易出现性能问题和内存溢出

类及方法的信息等比较难确定其大小，因此对于永久代的大小指定比较困难，太小容易出现永久代溢出，太 大则容易导致老年代溢出

永久代会为 GC 带来不必要的复杂度，并且回收效率偏低

Oracle 可能会将HotSpot 与 JRockit 合二为一，而JRockit没有所谓的永久代

PC 程序计数器：

什么是程序计数器：

我们来看看这个代码：

现在我们来换另外一种方式，看他的字节码，首先安装如下：

出现如下：

这里直接的给出进行分析：

PC寄存器的特点：

3：程序计数器是线程私有的，它的生命周期与线程相同，每个线程都有一个

4：此内存区域是唯一一个在Java虚拟机规范中没有规定任何OutOfMemoryError情况的区域（只保存一个，在运行时保存，由于运行基本必然比保存慢，所以这里基本不会报错，且运行之前就会提醒保存的）

一般来说pc寄存器是每个线程都有的，因为他是线程私有，一般私有的，代表线程创建之前，都会给他一个pc寄存器（或者其他说明私有的东西），或者jvm给该线程一个pc寄存器（或者其他说明私有的东西）

Java虚拟机的多线程是通过线程轮流切换并分配处理器执行时间的方式来实现的（也就是抢占cpu，在26章博客有说明），在任何一个确定的时刻，一个处 理器只会执行一条线程中的指令

虚拟机栈：

什么是虚拟机栈：

看如下代码：

实际上有些内部空间也会进行存放（栈帧），比如循环，或者try等等，注意即可

好了，一个图片你可能并不相信，那么现在我给出一个流程，看如下：

首先在对应的StackDemo sd = new StackDemo();进行调试

可以看到A入栈了，即的确是放在上面的（栈的特性，记得是先入后出哦），我们执行到最后的C：

什么是栈帧：

当然了上面的放大结构自然可能有其他的信息，但是上面四个是主要的，所以主要给出这四个

设置虚拟机栈的大小：

-Xss 为jvm启动的每个线程分配的内存（虚拟机栈内存）大小，默认JDK1.4中是256K，JDK1.5+中是1M，当然在不同的操作系统上，可能也有不同：

Linux/x64 (64-bit): 1024 KB

macOS (64-bit): 1024 KB

Oracle Solaris/x64 (64-bit): 1024 KB

Windows: The default value depends on virtual memory

JVM是Java Virtual Machine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的，一般用来操作java的

而 Java 跨平台的意义在于一次编译，处处运行，能够做到这一点 JVM 功不可没，比如我们在 Maven 仓库下载同一版本的 jar 包就可以到处运行，不需要在每个平台上再编译一次

现在的一些 JVM 的扩展语言，比如 Clojure、JRuby、Groovy 等，编译到最后都是 .class 文件，Java 语言的维护者，只需要控制好 JVM 这个解析器，就可以将这些扩展语言无缝的运行在 JVM 之上了

JVM 是 Java 程序能够运行的核心，但是需要注意，JVM 自己什么也干不了，你需要给它提供生产原料（.class 文件）

如果 .class 文件的规格是不变的，这两部分是可以独立进行优化的，但 Java 也会偶尔扩充一下 .class 文件的格式，增加一些字节码指令，以便支持更多的特性

我们可以把 Java 虚拟机可以看作是一台抽象的计算机，它有自己的指令集以及各种运行时内存区域（若学习过《计算机组成结构（原理）》或者相关的书籍，那么可以发现有类似的情况）

JVM分为五大模块：类装载器子系统，运行时数据区，执行引擎，本地方法接口和垃圾收集模块

永久代中的interned Strings（字符串常量池）和 class static variables（类静态变量）转移到了Java heap（堆）

类及方法的信息等比较难确定其大小，因此对于永久代的大小指定比较困难，太小容易出现永久代溢出，太大则容易导致老年代溢出

Java虚拟机的多线程是通过线程轮流切换并分配处理器执行时间的方式来实现的（也就是抢占cpu，在26章博客有说明），在任何一个确定的时刻，一个处理器只会执行一条线程中的指令

Java虚拟机栈中，每个栈帧都包含一个指向运行时常量池中该栈所属方法的符号引用，持有这个引用的目的是为了支持方法调用过程中的动态链接（Dynamic Linking）