JVM笔记

最新推荐文章于 2024-07-10 21:37:49 发布
最新推荐文章于 2024-07-10 21:37:49 发布
阅读量321 收藏
点赞数
分类专栏： JVM 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/New_22_comeon/article/details/124897348
版权

JVM类加载机制

概述

当Java程序运行某个类的Main方法时，首先需要通过类加载器把主类加载到JVM。
其中LoadClass的类加载过程有如下几步：
**加载 >> 验证 >> 准备 >> 解析 >> 初始化 **>> 使用 >> 卸载

  • 加载：在磁盘上查找并通过IO读入字节码文件，使用类时才会加载。例如：调用类的main()方法，new对象等等，在加载阶段会在内存中生成一个代表该类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口。
  • 验证：校验字节码文件的正确性。
  • 准备：给类的静态变量分配内存，并赋予默认值。
  • 解析：将符号引用替换成直接应用，该阶段会把一些静态方法(符号引用，比如：main()方法)替换为指向数据内存的指针或句柄等(直接引用)，这是所谓的静态链接过程(类加载期间完成)，动态链接是在程序运行期间完成的将符号引用替换成直接引用。
  • 初始化：对类的静态变量初始化为指定的值，执行静态代码块。
    在这里插入图片描述
    类被加载到方法区中后主要包含运行时常量池、类型信息、字段信息、方法信息、类加载器引用、对应的class实例的引用等信息。
    类加载器的引用：这个类到类加载器的实例的引用。
    对应的class实例的引用：类加载器在加载类信息放到方法区中后，会创建一个对应的Class的类型对象实例放到堆(Heap)中，作为开发人员访问方法区中类定义的入口和切入口点。
    注意：主类在运行过程中如果使用到了其他类，会逐步加载这些类，不是一次性加载的，按需加载，使用到才加载。

类加载器和双亲委派

Java中的类加载器有：

  • 引导类加载器（bootstrapLoad）：负责加载支持JVM运行的位于JRE的lib目录下的核心类库，如：rt.jar,charsets.jar等。
URL[] urls = Launcher.getBootstrapClassPath().getURLs();
        for (int i = 0 ;
             i < urls.length;i++){
            System.out.println(urls[i]);
        }
//结果
file:/C:/Program%20Files/Java/jdk1.8.0_191/jre/lib/resources.jar
file:/C:/Program%20Files/Java/jdk1.8.0_191/jre/lib/rt.jar
file:/C:/Program%20Files/Java/jdk1.8.0_191/jre/lib/sunrsasign.jar
file:/C:/Program%20Files/Java/jdk1.8.0_191/jre/lib/jsse.jar
file:/C:/Program%20Files/Java/jdk1.8.0_191/jre/lib/jce.jar
file:/C:/Program%20Files/Java/jdk1.8.0_191/jre/lib/charsets.jar
file:/C:/Program%20Files/Java/jdk1.8.0_191/jre/lib/jfr.jar
file:/C:/Program%20Files/Java/jdk1.8.0_191/jre/classes
  • 扩展类加载器（ExtClassLoader）：负责加载支持JVM运行的位于JRE的lib目录下的ext扩展目录中的JAR类包。
System.out.println(System.getProperty("java.ext.dirs"));
//结果
C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext;C:\WINDOWS\Sun\Java\lib\ext
  • 应用程序加载器（AppClassLoader）：负责加载ClassPath路径下的类包，主要是自己写的那些类。
System.out.println(System.getProperty("java.class.path"));
//结果
C:\Program Files\Java\jdk1.8.0_191\jre\lib\charsets.jar;
C:\Program Files\Java\jdk1.8.0_191\jre\lib\deploy.jar;
C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\access-bridge-64.jar;
C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\cldrdata.jar;
C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\dnsns.jar;
C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\jaccess.jar;
C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\jfxrt.jar;
C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\localedata.jar;
C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\nashorn.jar;
C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\sunec.jar;
C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\sunjce_provider.jar;
C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\sunmscapi.jar;
C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\sunpkcs11.jar;
C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\zipfs.jar;
C:\Program Files\Java\jdk1.8.0_191\jre\lib\javaws.jar;
C:\Program Files\Java\jdk1.8.0_191\jre\lib\jce.jar;
C:\Program Files\Java\jdk1.8.0_191\jre\lib\jfr.jar;
C:\Program Files\Java\jdk1.8.0_191\jre\lib\jfxswt.jar;
C:\Program Files\Java\jdk1.8.0_191\jre\lib\jsse.jar;
C:\Program Files\Java\jdk1.8.0_191\jre\lib\management-agent.jar;
C:\Program Files\Java\jdk1.8.0_191\jre\lib\plugin.jar;
C:\Program Files\Java\jdk1.8.0_191\jre\lib\resources.jar;
C:\Program Files\Java\jdk1.8.0_191\jre\lib\rt.jar;
F:\project-study\study-java\study-demo\target\classes;
F:\javaJar\org\openjdk\jol\jol-core\0.9\jol-core-0.9.jar;
E:\softwarePlace\IntelliJ IDEA 2021.2.1\lib\idea_rt.jar
  • 自定义类加载器：加载用户自己定义的路径下的类。

双亲委派

JVM默认使用Launcher的getClassLoader()方法返回的类加载器AppClassLoader的实例加载我们的应用程序。
在这里插入图片描述
双亲委派机制如图所示:加载一个类时，现委托为上一级加载器去加载，如果所有的上级没有在自己加载的路径中找到需要加载的类，上级在返回让其自己加载。

为什么设置双亲委派？（好处）

  • 沙箱安全机制：防止用自己手写的java类串改核心类 。比如：加载String（自己手写的String.java），加载时先委托上级加载，当走到引导类加载器时，找到了String，那么就会在引导类加载器完成加载，而不是用默认的应用加载器。
  • 避免类的重复加载：当父类已经加载了该类时，没有必要再重新加载一次。

打破双亲委派

为什么要打破双亲委派，双亲委派的局限性在哪？

用tomcat来说，当部署了多个war包时，且多个war包所依赖的Spring和jdk版本又不相同，那么因为双亲委派的存在，在启动第一个war包启动成功后，所有的类已加载完成，其他的war包启动时，因为双亲委派在向上一级委托类加载时，发现该类已加载成功（但是版本不同，名字相同），那么对于该war包而言，功能就会出现问题，因为自己所以来的那个版本的类没有加载，现在加载的类不是自己依赖的类的版本。因此需要打破双亲委派。

怎么打破双亲委派
通过自定义类加载器打破双亲委派机制。

Java对象的创建

java对象创建流程

对象创建的主要流程如下：
在这里插入图片描述

  • 类加载检查
    虚拟机遇到一条new指令时，首先将去检查这个指令的是否能在常量池中定位到一个类的符号引用，并且检查这个符号引用代表的类是否已经加载、解析和初始化过。如果没有，就必须先执行类的加载过程。
    注：new指令对应到语言层面将，new关键词、对象克隆、对象序列化等。

  • 分配内存
    再类检查通过后，接下来虚拟机将给新生对象分配内存。对象所需内存大小在类加载完成后完全可以确定，为对象分配内存的任务等同于把一块确定大小的内存从Java堆中划分出来。

    这个步骤有两个问题：

    • 如何划分内存
    • 在并发情况下，可能出现正在给对象A分配内存，指针还没来得及修改，对象B又同时使用了原来的指针分配内存情况。
    • 划分内存的方法
    1. 指针碰撞(Bump the Pointer)(默认方法)：如果Java堆中的内存时绝对规整的，所有用过的内存放在一边，空闲的内存放在另一边，中间放着一个指针作为分界点的指示器，那么所分配内存就仅仅是把那个指针指向空闲空间那边挪动一小段于对象大小相等的距离。
    2. 空闲列表(Free list)：如果Java堆内存并不是规整的，已使用的内存和空闲内存时相互交错的，那么就没办法使用指针碰撞了，虚拟机就必须维护一个列表，来记录哪些内存块是可以用的，在分配空间的时候找到一块足够大的空间分配给对象实例，并更新列表中的记录。
    • 解决并发问题的方法
      • CAS(compare and swap):虚拟机采用CAS配上失败重试的方式保证更新操作的原子性来对分配空间的动作进行同步处理。
      • 本地线程分配缓存（Thread Loacl Alloaction Buffer TLAB）：把内存分配的动作按照线程划分在不同的空间中进行，即每个现在在Java堆中预先分配一小块内存。通过**-XX:+/-UseTLAB参数来设置虚拟机是否使用TLAB（JVM默认是会开启的-XX:+UseTLAB**），-XX:TLABSize设置TLAB的大小。

  • 初始化
    内存分配完成后，虚拟机需要将分配到的内存空间都初始化为零（不包括对象头），如果使用TLAB，这一工程也可以提前值TLAB分配时进行。这一操作保证了对象的实例字段在Java代码中可以不赋值就直接使用，程序能访问到这些字段的数据类型以及所对应的零值。

  • 设置对象头
    初始化零值后，虚拟机需要对这些对象继续比要的设置，例如这个对象是哪个类的实例、如何找到类的元数数据信息、对象的哈希值、对象的GC分代年龄等信息。这些信息放在对象的对象头Object Header中。
    在HotSpot虚拟机中，对象在内存中存储的布局可以分为3块区域：对象头（Header）、 实例数据（Instance Data）
    和对齐填充（Padding）。 HotSpot虚拟机的对象头包括两部分信息，第一部分用于存储对象自身的运行时数据， 如哈
    希码（HashCode）、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时 间戳等。对象头的另外一部分
    是类型指针，即对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例。
    在这里插入图片描述

  • 执行 init 方法
    执行init方法，即对象按照程序员的意愿进行初始化。对应到语言层面上讲，就是为属性赋值（注意，这与上面的赋零值不同，这是由程序员赋的值），和执行构造方法。

压缩指针 什么是压缩指针？

  1. jdk1.6 update14开始，在64bit操作系统中，JVM支持指针压缩
  2. jvm配置参数：UseCompressedOops，compressed – 压缩、oops（ordinary object pointer）-- 对象指针
  3. 启用压缩指针：-XX:+UseCompressedOops(默认开启)，禁止压缩指针：-XX:-UseCommpressedOops

为什么要进行指针压缩？

  1. 在64位平台的HotSpot中使用32位指针，内存使用会多出1.5倍左右，使用较大指针在内存和缓存之间移动数据时，占用较大带宽，同时GC也会较大压力
  2. 为了减少64位平台下的内存消耗，启动压缩指针功能。
  3. 在jvm中，32位地址的最大内存为4G（2的32次方），可以通过对对象指针的压缩编码、解码方式进行优化，使jvm只用32位地址就可以支持更大的内存配置（小于等于32G）。
  4. 堆内存小于4G时，不需要启动指针压缩，jvm会直接去除高32位地址，即使用低虚拟地址空间。
  5. 堆内存大于32G时，压缩指针会失效，会强制使用64位（及8字节）来对java对象进行寻址，这就会出现1问题，所以推荐堆内存不要超过32G为好。

Java对象的内存分配在这里插入图片描述

栈分配满足条件：

  • 逃逸分析：定该对象不会被外部访问（举例：没有返回类型）。

  • 标量替换：通过逃逸分析确定该对象不会被外部访问，并且对象可以被进一步分解时，JVM不会创建该对象，而是将该对象成员变量分解若干个被这个方法使用的成员变量所代替，这些代替的成员变量在栈帧或寄存器上分配空间，这样就不会因为没有一大块连续空间导致对象内存不够分配。

  • 开启逃逸分析：-XX:+DoEscapeAnalyysis*(jdk1.7后默认开启，关闭时+改为-)
    开启标量替换参数：-XX:+EliminateAllocations，（JDK7之后默认开启关闭时+改为-）
    标量与聚合量：标量即不可被进一步分解的量，而JAVA的基本数据类型就是标量（如：int，long等基本数据类型以及reference类型等），标量的对立就是可以被进一步分解的量，而这种量称之为聚合量。而在JAVA中对象就是可以被进一步分解的聚合量。

  • Eden区
    年轻代和来年代分配比例默认是1:2
    Eden区和Survivor的分配比例默认是8:1:1

    Minor GC和Full GC 有什么不同呢？

    • Minor GC/Young GC：指发生新生代的的垃圾收集动作，Minor GC非常频繁，回收速度一般也比较快。
    • Major GC/Full GC：一般会回收老年代 ，年轻代，方法区的垃圾，Major GC的速度一般会比Minor GC的慢10倍以上
      JVM默认有这个参数-XX:+UseAdaptiveSizePolicy(默认开启)，会导致这个8:1:1比例自动变化，如果不想这个比例有变化可以设置参数-XX:-UseAdaptiveSizePolicy

  • 大对象
    大对象就是需要大量连续内存空间的对象（比如：字符串、数组）。JVM参数 -XX:PretenureSizeThreshold 可以设置大对象的大小，如果对象超过设置大小会直接进入老年代，不会进入年轻代，这个参数只在 Serial 和ParNew两个收集器下有效。
    使用：-XX:PretenureSizeThreshold=1000000 (单位是字节) -XX:+UseSerialGC

  • 分代年龄
    当对象每次不被Minor GC回收，那么都西昂的年龄就长一岁，当到达一定年龄（默认为15，CMS为6，不同的垃圾处理器年龄会有一些不同，该阀值可以通过参数：-XX:MaxTenuringThreshold进行设置）就会进入老年代（永久代）。

  • 动态年龄判断
    当前放对象的Survivor区域里(其中一块区域，放对象的那块s区)，一批对象的总大小大于这块Survivor区域内存大小的50%(-XX:TargetSurvivorRatio可以指定)，那么此时大于等于这批对象年龄最大值的对象，就可以直接进入老年代了，例如Survivor区域里现在有一批对象，年龄1+年龄2+年龄n的多个年龄对象总和超过了Survivor区域的50%，此时就会把年龄n(含)以上的对象都放入老年代。这个规则其实是希望那些可能是长期存活的对象，尽早进入老年代。对象动态年龄判断机制一般是在minor gc之后触发的。

  • 老年代空间分配担保机制
    年轻代每次minor gc之前JVM都会计算下老年代剩余的可用空间。如果这个可用空间小于年轻代里现在所有对象的大小之和（包括垃圾对象），就会看一个"-XX:-HandlePromotionFailure"(1.8默认设置了)的参数是否设置了。如果有这个参数，就会看老年代的可用内存大小，是否大于之前每一次minor gc后进入老年代的对象的平均大小。如果小于或者之前的参数没有设置，那么就会触发一次full gc，对老年代空间进行一次垃圾回收，，如果回收完还没有足够的空间就会报错OOM（Out Of Memory）。
    当然，如果minor gc之后剩余存活的需要挪动到老年代的对象大小还是大于老年代可用空间，那么也会触发full gc，full
    gc完之后如果还是没有空间放minor gc之后的存活对象，则也会发生“OOM”

对象内存回收

  • 引用计数法
    给对象中添加一个引用计数器，每当有一个地方引用它，计数器就加1；当引用失效，计数器就减1；任何时候计数器为0的对象就是不可能再被使用的。
    这个方法实现简单，效率高，但是目前主流的虚拟机中并没有选择这个算法来管理内存，其最主要的原因是它很难解决对象之间相互循环引用的问题。
  • 可达性分析算法
    将“GC Roots” 对象作为起点，从这些节点开始向下搜索引用的对象，找到的对象都标记为非垃圾对象，其余未标记的对象都是垃圾对象。
    GC Roots根节点：线程栈的本地变量、静态变量、本地方法栈的变量等等

常见引用类型
java的引用类型一般分为四种：强引用、软引用、弱引用、虚引用

  • 强引用：普通的变量引用

    public static User user = new User();

  • 弱引用：将对象用SoftReference软引用类型的对象包裹，正常情况不会被回收，但是GC做完后发现释放不出空间存放新的对象，则会把这些软引用的对象回收掉。软引用可用来实现内存敏感的高速缓存。

    public static SoftReference<User> user = new SoftReference<User>(new User());

    软引用在实际中有重要的应用，例如浏览器的后退按钮。按后退时，这个后退时显示的网页内容是重新进行请求还是从
    缓存中取出呢？这就要看具体的实现策略了。
    （1）如果一个网页在浏览结束时就进行内容的回收，则按后退查看前面浏览过的页面时，需要重新构建
    （2）如果将浏览过的网页存储到内存中会造成内存的大量浪费，甚至会造成内存溢出

  • 软引用：将对象用WeakReference软引用类型的对象包裹，弱引用跟没引用差不多，GC会直接回收掉，很少用。

    public static WeakReference<User> user = new WeakReference<User>(new User());

  • 虚引用：虚引用也称为幽灵引用或者幻影引用，它是最弱的一种引用关系，几乎不用

finalize()方法最终判定对象是否存活
即使在可达性分析算法中不可达的对象，也并非是“非死不可”的，这时候它们暂时处于“缓刑”阶段，要真正宣告一个对象死亡，至少要经历再次标记过程。
标记的前提是对象在进行可达性分析后发现没有与GC Roots相连接的引用链。

  1. 第一次标记并进行一次筛选。
    筛选的条件是此对象是否有必要执行finalize()方法。
    当对象没有覆盖finalize方法，对象将直接被回收。
  2. 第二次标记
    如果这个对象覆盖了finalize方法，finalize方法是对象脱逃死亡命运的最后一次机会，如果对象要在finalize()中成功拯救自己，只要重新与引用链上的任何的一个对象建立关联即可，譬如把自己赋值给某个类变量或对象的成员变量，那在第二次标记时它将移除出“即将回收”的集合。如果对象这时候还没逃脱，那基本上它就真的被回收了。
    注意：一个对象的finalize()方法只会被执行一次，也就是说通过调用finalize方法自我救命的机会就一次。（并不鼓励使用finalize()方法，它运行代价高昂，不确定性大，无法保证各个对象的调用顺序。）

如何判断一个类是无用的类

  • 该类所有的实例都已经被回收，也就是 Java 堆中不存在该类的任何实例。
  • 加载该类的 ClassLoader 已经被回收。
  • 该类对应的 java.lang.Class 对象没有在任何地方被引用，无法在任何地方通过反射访问该类的方法。

JVM

JVM内存模型

在这里插入图片描述

  • 堆：用来存放对象实例

  • 栈：用来存储变量以及可以存储部分对象—依赖于逃逸分析与标量替换，可以设置，每个线程会在栈区开辟一块栈空间，为线程唯一，只有当前线程可用。

  • 本地方法栈

  • 方法去（元空间）：用来存储加载后的字节码文件，以及类的成员变量

  • 程序计数器：记录程序执行到哪一步

    我们新创建的对象都会存放到年轻代Eden区（除非对象太大放不下会直接放到OLD区 ），S0和S1叫Survivor区，每次minor
    gc时，对象会在S0和S1之间切换，切换次数达到15次后会切换到老年代。

JVM内存参数

  • 元空间参数

    • -XX:MaxMetaspaceSize:设置元空间的最大值，默认为-1，及不限制，或者说只受本地内存大小限制。

    • -XX:MetaspaceSize:元空间触发full gc的初始阀值（元空间无固定大小）,以字节为单位，默认为21M，达到阀值就会触发full gc进行类型给卸载，同时收集器会堆改值进行调整；如果释放了大量空间，就是当降值；如果释放的空间较少，那么在不超过**-XX:MaxMetaspaceSize**（如果设置了的话）的大小的情况下，适当提高该值。

      这个跟早期jdk版本的-XX:PermSize参数意思不一样，- XX:PermSize代表永久代的初始容量。
      由于调整元空间的大小需要Full GC，这是非常昂贵的操作，如果应用在启动的时候发生大量Full GC，通常都是由于永久代或元空间发生
      了大小调整，基于这种情况，一般建议在JVM参数中将MetaspaceSize和MaxMetaspaceSize设置成一样的值，并设置得比初始值要大，
      对于8G物理内存的机器来说，一般我会将这两个值都设置为256M。

  • JVM参数常用：

    • ‐Xms2048M：堆空间的最小值为2048M
    • -Xmx2048M：对空间的最大值为2048M
    • -Xmn1024M：新生代大小为1024M
    • -Xss512K：栈空间大小为512K（默认为1M）

    注意：
    -Xss设置越小count值越小，说明一个线程栈里能分配的栈帧就越少，但是对JVM整体来说能开启的线程数会更多

走在未来之路上
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
-XX:+UseCompressedOops 与 -XX:-UseCompressedOops
E_K_in的博客
04-20 8500
​ 开启(-XX:+UseCompressedOops) 可以压缩指针。 关闭(-XX:-UseCompressedOops) 可以关闭压缩指针。 1:关闭(-XX:-UseCompressedOops) 可以关闭压缩指针，对象头16字节(klass pointer 8字节)reference 8字节 2：开启(-XX:+UseCompressedOops) 可以压缩指针对象头12...
不需要再手工指定JVM启动参数-XX:+UseCompressedOops
铁锚的CSDN博客
01-01 2695
技术团队通过 GCeasy 工具分析完几千次用户上传的GC日志后, 发现一个现象: 仍然有很多Java程序传入了JVM启动参数 -XX:+UseCompressedOops。 实际上，如果JVM的版本在 Java SE 6 update 23 及以上, 则不需要再设置 -XX:+UseCompressedOops 参数, 因为默认会开启。 “OOP” 表示普通对象指针(Ordinary Object Pointer), 这种指针是对某个对象的托管指针(managed pointer)。 OOP占用的空间
UseCompressedOops 压缩指针、JOL内存分布工具学习
leo187的博客
03-28 1047
为什么需要压缩 通常64位JVM消耗的内存会比32位的大1.5倍，这是因为对象指针在64位架构下，长度会翻倍（更宽的寻址）。对于那些将要从32位平台移植到64位的应用来说（假如编译和运行环境同为32或同为64不需要手动开启），平白无辜多了1/2的内存占用，这是开发者不愿意看到的。幸运的是，从JDK 1.6 update14开始，64 bit JVM正式支持了 -XX:+UseCompres...
jvm性能调优学习总结
得之专栏
06-28 1557
jvm
jvm配置参数（记录）
lc0055的博客
03-24 412
‐Xms2048M（简写） -XX:InitialHeapSize=100M 初始化堆大小 -XX:CICompilerCount=1 最大并行编译数 ‐Xmx2048M -XX:MaxHeapSize=100M 堆的最大值 ‐Xmn1024M 年轻代大小 -XX:NewSize=20M 年轻代大小 -XX:MaxNewSize=50M 年轻代最大值 -Xss512K 线程的大小 -Xss设置越小count值越小，说明一个线程栈里能分配的栈帧就越少，但是对JVM整体来说能开启的线程数会更多 ‐XX:
JVM笔记（阳哥）.zip
09-14
《JVM笔记（阳哥）》是一份深入探讨Java虚拟机（JVM）的资料，由阳哥精心整理。这份笔记涵盖了JVM的基础概念、内存管理、类加载机制、性能优化等多个方面，对于理解Java程序的运行机制以及提升开发效率具有重要的...
jvm笔记
12-16
JVM 笔记 今天，我们要讨论的是 JVM 的笔记，这个笔记包括了 JVM 的基本结构、类加载机制、类文件格式等内容。 首先，让我们来看一下 JVM 的基本结构。JVM 可以分为三个部分：CLASS LOADER、RUN TIME DATA AREA 和...
JVM笔记.docx
06-09
【JVM 体系结构概述】 Java 虚拟机（JVM）是Java应用程序的核心，它作为操作系统上的一个抽象层，使得Java代码可以在任何支持JVM的平台上运行，无需关心底层系统的具体细节。JVM主要由以下几个部分构成： 1. 类...
kyle所著JVM笔记
05-22
观宋红康老师视频所著JVM笔记
深入JVM笔记word版
12-05
深入JVM截取的一些自己认为需要了解，外加一些博客链接，还有转载的一些。不是本人所写，因为是自己看的，想着方便下大家，有些忘记转载的那篇啦，没有写转载作者，先抱歉下，不行我删除
【JVM调优】JDK11-JVM基本参数调优以及日志打印
qqqking的博客
12-30 7794
Parm: -Xmx2g -Xms1g -Xss256k -XX:MaxDirectMemorySize=256m -XX:+UseG1GC -XX:+UseCompressedOops -XX:+UseCompressedClassPointers -XX:+SegmentedCodeCache -verbose:gc -XX:+PrintCommandLineFlags -XX:+ExplicitGCInvokesConcurrent -Xlog:gc*=debug:file=/data2/logs/
jvm之-XX:+UseCompressedOops作用
qq_30908729的博客
05-31 1万+
jvm之-XX:+UseCompressedOops作用 解决方法： new一个空对象在32为系统中占用内存大小是8byte（对象头，在堆中）+4byte（对象的引用地址，在栈中）=12byte； new一个空对象在64为系统中占用内存大小是16byte（对象头，在堆中）+8byte（对象的引用地址，在栈中）=24byte； 可想而知同一个对象在64位系统中占的内存加大一半了，不仅消...
深入理解Java内存架构
极客重生
03-04 597
hi，大家周末好，今天给大家带来一篇硬核的技术文章，本文我们将从计算机组成原理的角度详细阐述对象在JVM内存中是如何布局的，以及什么是内存对齐，如果我们头比较铁，就是不进行内存对齐会造成什...
idea 启动参数设置
chuan_zhang_ak的博客
08-25 2629
系统原参数： -Xms128m -Xmx2032m -XX:ReservedCodeCacheSize=240m -XX:+UseConcMarkSweepGC -XX:SoftRefLRUPolicyMSPerMB=50 -ea -XX:CICompilerCount=2 -Dsun.io.useCanonPrefixCache=false -Djava.net.preferIPv4Stack=true -Djdk.http.auth.tunneling.disabledSchemes="" -XX:..
java 内存调优 -Xms2048m -Xmx2048m -Xmn512m
热门推荐
哲学天空的博客
03-15 1万+
对于JVM内存配置参数： -Xmx10240m -Xms10240m -Xmn5120m -XXSurvivorRatio=3 -Xmx10240m：代表最大堆 -Xms10240m：代表最小堆 -Xmn5120m：代表新生代 -XXSurvivorRatio=3：代表Eden:Survivor = 3 根据Generation-Collection算法(目前大部分JVM采...
配置Java开发环境
最新发布
Broken_x的博客
07-10 1591
Java开发环境配置

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

走在未来之路上

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值