JVM常用参数解析

最新推荐文章于 2023-03-13 09:58:25 发布
最新推荐文章于 2023-03-13 09:58:25 发布
阅读量345 收藏 1
点赞数
分类专栏： JVM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuzewei2015/article/details/90545418
版权
  1. JVM的参数类型：其中标配参数和x参数：

        
  2. 用的较多的是xx参数：
    运行的java进程编号显示：jps -l  ；
    1）boolean类型： jinfo -flag 配置项 进程编号（或jinfo -flags 进程编号）：用来查看某个进程的配置（在VM options中可以加参数）：+(-)PrintGCDetails表示是否打印垃圾收集细节；+(-)UseSerialGC表示是否使用串行收集器；
    2）KV（key，value）设置类型：-XX:属性key=属性值value； MetaspaceSize =  128m；MaxTenuringThreshold = 15；（由默认值改为所设置的值）；
    3）两个经典参数：-Xms : 等价于  -XX:InitialHeapSize ； -Xmx：等价于 -XX:MaxHeapSize；
      
    public class parameterTest {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("--------");
        Thread.sleep(Integer.MAX_VALUE);
    }
}

     
  3. 查看JVM默认值：java -XX:+PrintFlagsInitial：主要查看初始默认；java -XX:+PrintFlagsFinal：主要查看修改更新，其中带 ：= 表示（JVM或人为）修改过的参数； java -XX:+PrintCommandLineFlags ： 可以看到默认的垃圾回收器


     
  4. 使用程序打印jvm内存及结果：

    常用参数：
  5. -Xss: 设置单个线程栈的大小，一般默认为512K~1024K；等价于：-XX:ThreadStackSize；
    输出结果中0代表默认初始值
  6. -Xmn：设置年轻代大小；
  7. -XX:MetaspaceSize：设置元空间大小 ；
  8. 常见参数配置：
    -Xms128m -XXmx4096m -Xss1024k -XX: MetaspaceSize=1024m -XX:+PrintFlagsFinal -XX:+PrintGCDetails -XX:+UseSerialGC
  9. -XX:+PrintGCDetails：
    使用-XX:+PrintGCDetails  （未设置其他参数）结果：

     
  10. 设置值使其OOM：

         


    GC：

    FullGC:


     
  11. -XX:SurvivorRatio：设置新生代中Eden和s0/s1空间的比例；默认：-XX:SurvivorRatio=8   eden:S0:S1 = 8:1:1
     
  12. -XX:NewRatio：配置年轻代与老年代在堆结构的占比，默认-XX:NewRatio=2，年轻代占1，老年代占2，年轻代占整个堆的1/3
     
  13. -XX:MaxTenuringThreshold：设置垃圾最大年龄；默认值为-XX:MaxTenuringThreshold=15；（可设置0~15）
     
  14. 引用的总体架构：

     
  15. 强引用：当内存不足，JVM开始垃圾回收，对于强引用对象，就算是出现了OOM也不会对该对象进行回收。在Java中最常见的就是强引用，把一个对象赋给一个引用变量，这个引用变量就是一个强引用。当一个对象被强引用变量引用时，它处于可达状态，是不可能被垃圾回收机制回收的。因此强引用时内存泄漏的主要原因。
  16. 软引用：用java.lang.ref.SoftReference类来实现，可以让对象豁免一些垃圾收集。对于只有软引用的对象来说，当系统内存充足时它不会被回收，当系统内存不足时它会被回收；软引用通常用在对内存敏感的程序中，比如高速缓存就用到软引用，内存够用的时候就保留，不够用就回收。
  17. 弱引用：用java.lang.ref.WeakReference类来实现；对于只有弱引用的对象来说，只要垃圾回收机制一运行，不管jvm的内存空间是否足够，都会回收该对象占用的内存。
  18. 虚引用：用java.lang.ref.PhantomReference类来实现；它形同虚设，如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收，它不能单独使用也不能通过它来返回对象，虚引用必须和引用队列（ReferenceQueue）一起使用。PhantomReference的get()方法总是返回null；
    虚引用的主要作用是跟踪对象被垃圾回收的状态，目的在这个对象被收集器回收的时候收到一个系统通知或者后续添加进一步的处理。Java技术允许使用finalize方法在垃圾收集器将对象从内存中清除之前做必要的清理工作。
  19. 引用队列：ReferenceQueue是用来配合工作的；创建引用的时候可以指定关联的队列，当GC释放内存对象的时候，会将引用加入到引用队列。如果程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动，这相当于是一种通知机制。
  20. 实例： 
        @Test
    public void RefernceSTest(){
        //强引用
        Object object = new Object();
        Object object1 = object;
        object = null;
        System.gc();
        System.out.println(object1);//java.lang.Object@4ee285c6
    }
    @Test
    public void SoftMemoryEnoughTest(){
        //软引用
        Object object = new Object();
        SoftReference<Object> softReference = new SoftReference<>(object);
        System.out.println(object);//java.lang.Object@4ee285c6
        System.out.println(softReference.get());//java.lang.Object@4ee285c6

        object = null;
        System.gc();
        System.out.println(object);//null
        System.out.println(softReference.get());//java.lang.Object@4ee285c6
    }
    @Test
    public void SoftMemoryNotEnoughTest(){
        //JVM配置，故意产生大对象并配置小内存；
        //-Xms5m -Xmm5m -XX:PrintGCDetails
        Object object = new Object();
        SoftReference<Object> softReference = new SoftReference<>(object);
        System.out.println(object);//java.lang.Object@4ee285c6
        System.out.println(softReference.get());//java.lang.Object@4ee285c6

        object = null;

        try{
            byte[] bytes = new byte[30*1024*1024];
        }catch (Throwable e){
            e.printStackTrace();
        }finally {
            System.out.println(object);//null
            System.out.println(softReference.get());//null
        }
    }
    @Test
    public void WeakTest(){
        //弱引用
        Object object = new Object();
        WeakReference<Object> weakReference = new WeakReference<>(object);
        System.out.println(object);//java.lang.Object@4ee285c6
        System.out.println(weakReference.get());//java.lang.Object@4ee285c6

        object = null;
        System.gc();
        System.out.println(object);//null
        System.out.println(weakReference.get());//null
    }
    @Test
    public void HashMapTest(){
        HashMap<Integer,String> map = new HashMap<>();
        Integer key = new Integer(1);
        String value = "Value";
        map.put(2,"value");
        map.put(key, value);
        System.out.println(map);//{2=value, 1=Value}

        key = null;
        System.out.println(map);//{2=value, 1=Value}

        System.gc();
        System.out.println(map);//{2=value,1=Value}
    }
    @Test
    public void WeakHashMapTest(){
        WeakHashMap<Integer,String> map = new WeakHashMap<>();
        Integer key = new Integer(1);
        String value = "Value";
        map.put(key, value);
        map.put(2,"value");
        System.out.println(map);//{2=value, 1=Value}

        System.out.println("----------");
        key = null;
        System.out.println(map);//{2=value, 1=Value}

        System.out.println("----------");
        System.gc();
        System.out.println(map);//{2=value}
    }
    @Test
    public void ReferenceTest() throws InterruptedException {
        Object object = new Object();
        ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>();
        WeakReference<Object> weakReference = new WeakReference<>(object,referenceQueue);
        System.out.println(object);//java.lang.Object@4ee285c6
        System.out.println(weakReference.get());//java.lang.Object@4ee285c6
        System.out.println(referenceQueue.poll());//null

        System.out.println("------------");
        object = null;
        System.gc();
        Thread.sleep(500);
        System.out.println(object);//null
        System.out.println(weakReference.get());//null
        System.out.println(referenceQueue.poll());//java.lang.ref.WeakReference@621be5d1
    }

    @Test
    public void PhantomTest() throws InterruptedException {
        //虚引用
        Object object = new Object();
        ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>();
        PhantomReference<Object> phantomReference = new PhantomReference<>(object,referenceQueue);
        System.out.println(object);//java.lang.Object@4ee285c6
        System.out.println(phantomReference.get());//null
        System.out.println(referenceQueue.poll());//null

        System.out.println("------------");
        object = null;
        System.gc();
        Thread.sleep(500);
        System.out.println(object);//null
        System.out.println(phantomReference.get());//null
        System.out.println(referenceQueue.poll());//java.lang.ref.WeakReference@621be5d1
    }

     

  21. 假如有一个应用需要读取大量的本地图片：如果每次读取图片都是从硬盘中读取会严重影响性能；如果一次性全部加载到内存中又可能造成内存溢出；
    使用软应用可以解决这个问题：用一个HashMap来保存图片的路径和相应图片对象关联的软引用之间的映射关系，在内存不足时，JVM会自动回收这些缓存图片对象所占用的空间，有效避免OOM问题：
    Map<String,SoftReference<BItmap>> imageCache = new HashMap< String,SoftReference<BItmap>>();
     
  22. 常见OOM异常：属于 Error

    StackOverFlowError

    OutofMemeoryError: java heap space

    OutofMemeoryError: GC overhead limit exceeded ：
    GC回收时间过长会抛出OutOfMemoryError：超过98%的时间用来做GC并且回收了不到2%的堆内存，连续多次GC都只回收了不到2%的极端情况下才会抛出。假如不抛出GC overhead limit 错误：GC清理出的内存很快又会被填满，迫使GC再次执行，形成恶性循环。CPU使用率一直是100%，而GC却没有任何成果。


    OutofMemeoryError: Direct buffer memory 

    写NIO程序经常使用ByteBuffer来读取或者写入数据，这是一种基于通道（Channel）与缓冲区（Buffer）的I/O方式。它可以使用Native函数库直接分配堆外内存，然后通过一个存储在Java堆里面的DirectByteBuffer对象作为这块内存的引用进行操作。这样能在一些场景中提高性能，因为避免了在JVM堆和Native堆中来回复制数据。
    byteBuffer.allocate(capability)是分配JVM堆内存，属于GC管辖范围，由于需要拷贝所以速度相对较慢。byteBuffer.allocateDirect(capability)是分配OS本地内存，不属于GC管辖范围，速度相对较快。
    如果不断分配本地内存，堆内存很少使用，那么JVM就不需要执行GC，DirectByteBuffer对象们就不会被回收，这时候堆内存充足，但本地内存可能已经用光了，再次尝试分配本地内存时就会出现OutOfMemoryError


    OutofMemeoryError: unable to create new native thread

    高并发请求服务器时，经常出现此异常；准确地讲native thread异常与对应的平台有关。非root用户登入linux系统测试和服务器级别调参调优情况存在；
    导致原因：1你的应用创建了太多线程，一个应用进程创建多个线程，超过系统承载极限。2服务器不允许应用程序创建这么多线程，linux系统默认允许单个进程创建1024个线程（非root用户）。
    解决办法：1降低创建的线程数量。  2可以通过修改linux服务器配置，扩大linux默认限制。



    OutofMemeoryError: Metaspace

    Metaspace是方法区中在Hotspot中的实现，它与持久代最大的区别在于：Metaspace并不在虚拟机内存中而不是本地内存中
    Class metadata(the virtual machines internal presentation of java class)存储于Metaspce的native memory
    其中存放了一下信息：虚拟机加载的类信息（rt.jar包中java.lang包下中的类的信息）、常量池、静态变量、即时编译后的代码。
    模拟Metadata空间溢出，我们不断生成类往元空间灌，类占据的空间总是会超过Metaspace指定的空间大小的

  23. OOM示例代码： 
        @Test
    public void StackOverFlowErrorTest(){
        stackover();//java.lang.StackOverflowError
    }
    private void stackover(){
        //不停的调用自己，栈的大小默认512-1024K，使其出现StackOverFlowError
        //递归调用，将栈空间称爆
        stackover();
    }
    @Test
    public void JVMHeapSpaceTest(){
        //堆区内存不足异常
        String str = "liu";
        while (true){
            str += str  + new Random().nextInt(111111)+ new Random().nextInt(2222222);
            str.intern();//不停的new对象，占空间
        }//java.lang.OutOfMemoryError: Java heap space
    }
    @Test
    public void GCOverHeadDemo(){
        //-Xms10m  -Xmx10m   -XX:+PrintGCDetails -XX:MaxDirectMemorySize=5m
        int i=0;
        List<String> list = new ArrayList<>();
        try{
            while (true){
                list.add(String.valueOf(++i).intern());
            }
        }catch (Exception e){
            System.out.println("**************i:"+i);
            e.printStackTrace();
            throw e;
        }//java.lang.OutOfMemoryError: GC overhead limit exceeded
    }
    @Test
    public void DirectBufferMemoryTest(){
        //-Xms10m  -Xmx10m   -XX:+PrintGCDetails -XX:MaxDirectMemorySize=5m
        System.out.println("配置的maxDirectMemory：" +
                (sun.misc.VM.maxDirectMemory()/(double)1024/1024) + "MB");
        try{
            Thread.sleep(3000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        ByteBuffer bb = ByteBuffer.allocateDirect(6*1024*1024);
    }//java.lang.OutOfMemoryError: Direct buffer memory
    @Test
    public void UnableNewNativeThreadTest(){
        //需要配置linux为非root用户模式
        for(int i = 0; ;i++){
            System.out.println("---------------i = " + i);
            new Thread(()->{
                try {
                    Thread.sleep(Integer.MAX_VALUE);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            },""+i).start();
        }
    }//OutofMemeoryError: unable to create new native thread

     

  24. 主要垃圾收集器：Serial，parallel，CMS，G1，ZGC

    串行垃圾收集器：Serial：为单线程环境设计且只使用一个线程进行垃圾回收，会暂停所有的用户线程。所以不适合服务器环境。

    并行垃圾收集器：parallel：多个垃圾收集线程并行工作，此时用户线程是暂停的，适用于科学计算、大数据处理首台处理等弱交互场景。

    并发垃圾收集器：CMS（UseConcMarkSweepGC并发标记清除）：用户线程和垃圾收集线程同时执行（不一定是并行，可能交替执行），不需要停顿用户线程；互联网公司多用它，适用对响应时间有要求的场景。

    G1垃圾收集器将堆内存分割成不同的区域然后并发的对其进行垃圾回收。
     
  25. 默认的6种垃圾收集器： 
    //-Xms10m -Xmx10m -XX:+PrintGCDetails -XX:+PrintCommandLineFlags -XX:+UseSerialGC     (DefNew + Tenured)
//-Xms10m -Xmx10m -XX:+PrintGCDetails -XX:+PrintCommandLineFlags -XX:+UseParNewGC     (ParNew + Tenured)
//-Xms10m -Xmx10m -XX:+PrintGCDetails -XX:+PrintCommandLineFlags -XX:+UseParallelGC    (PSYoungGen + ParOldGen)
//-Xms10m -Xmx10m -XX:+PrintGCDetails -XX:+PrintCommandLineFlags -XX:+UseParallelOldGC    (PSYoungGen + ParOldGen)
//-Xms10m -Xmx10m -XX:+PrintGCDetails -XX:+PrintCommandLineFlags     (PSYoungGen + ParOldGen)  (不加默认为这个)
//-Xms10m -Xmx10m -XX:+PrintGCDetails -XX:+PrintCommandLineFlags -XX:+UseConcMarkSweepGC    (Par new generation + concurrent)
//-Xms10m -Xmx10m -XX:+PrintGCDetails -XX:+PrintCommandLineFlags -XX:+UseG1GC    (PSYoungGen + ParOldGen)
  27.  

    CMS优点：并发收集低停顿

    缺点：1并发执行，对CPU资源压力大 2采用的标记清除算法会导致大量碎片

  28. G1比起CMS有两个优势：

    1、G1不会产生内存碎片  

    2、可以精确控制停顿。该收集器是把整个堆划分成多个固定大小的区域，每次根据允许提供的时间去收集垃圾最多的区域。
     













  29.  
lzw2019sun
关注
专栏目录
JVM常用调优参数
qq_45726776的博客
01-14 1507
1）-Xms20M 表示设置JVM启动内存的最小值为20M，必须以M为单位 （2）-Xmx20M 表示设置JVM启动内存的最大值为20M，必须以M为单位。将-Xmx和-Xms设置为一样可以避免JVM内存自动扩展。大的项目-Xmx和-Xms一般都要设置到10G、20G甚至还要高 （3）-verbose:gc 表示输出虚拟机中GC的详细情况 （4）-Xss128k 表示可以设置虚拟机栈的大小为128k （5）-Xoss128k 表示设置本地方法栈的大小为128k。不过HotSpot并不区分虚拟机栈和本地方法栈，
JVM常用启动参数
Stay Hungry, Stay Foolish!
05-29 5167
目录JVM常用启动参数系统属性参数运行模式参数堆内存设置参数显式指定堆内存`–Xms`和`-Xmx`显式新生代内存显示指定永久代/元空间的大小其他常用参数GC设置参数垃圾回收器GC记录分析诊断参数JavaAgent参数 文章放置于：https://github.com/zgkaii/CS-Study-Notes，欢迎批评指正！ JVM常用启动参数 JVM启动参数的前缀主要有-、-D、-X、-XX、+/-、: 以-开头为标准参数，所以的JVM都要实现这些参数，并且向后兼容。例如-server。 -D
Java并发编程（三）Thread类的使用
heng615975867的专栏
09-11 318
一.线程的状态 线程从创建到最终的消亡，要经历若干个状态。一般来说，线程包括以下这几个状态：创建(new)、就绪(runnable)、运行(running)、阻塞(blocked)、time waiting、waiting、消亡（dead）。 当需要新起一个线程来执行某个子任务时，就创建了一个线程。但是线程创建之后，不会立即进入就绪状态，因为线程的运行需要一些条件（比如内存资源，在前面的JVM内存区域划分一篇博文中知道程序计数器、Java栈、本地方法栈都是线程私有的，所以需要为线程分配一定..
7天掌握NIO和SOCKET，第四天，通道锁的position和size详解，共享锁和互斥锁之间的关系
qq_40666620的博客
05-03 202
import java.io.FileNotFoundException; import java.io.IOException; import java.io.RandomAccessFile; import java.nio.ByteBuffer; import java.nio.channels.FileChannel; public class test_04 { public...
【权威说明】从JVM源码的角度带你看明白Thread.sleep() 是否占用CPU？
最新发布
唐欢
03-13 1639
在示例中把进程的ID打印出来了，打印出来的原因是可以使用jstack (pid 表示java进程id，可用jps命令查看) 查看所有线程的状态，jstack可以生成或导出jvm 虚拟机运行实例当前时刻的线程快照。Thread.sleep的在jvm层面上是调用thread中SleepEvent对象的**park()**方法实现阻塞线程，在此过程中会通过判断时间戳来决定线程的睡眠时间是否达到了指定的毫秒。如果睡眠的时间为0，那么会调用系统级别的睡眠方法os::sleep()，睡眠时间为最小时间间隔。
-XX参数
Leon_Jinhai_Sun的博客
02-05 1143
使用得最多的参数类型 非标准化参数，相对不稳定，主要用于JVM调优和Debug a.Boolean类型 格式：-XX:[+-]<name> +或-表示启用或者禁用name属性 比如：-XX:+UseConcMarkSweepGC 表示启用CMS类型的垃圾回收器 -XX:+UseG1GC 表示启用G1类型的垃圾回收器 b.非Boolean类型 格式：-XX<name>=<value>表示name属性的值是value 比如：-XX:MaxGCPauseMillis=50
初识Netty原理(三)——解码和编码
aa1358075776的博客
11-04 630
在Netty底层读入的是ByteBuf二进制数据，在实际开发中，需要将它解码为Java的POJO对象，处理完业务后，需要将Java的POJO对象编码为ByteBuf二进制数据放进通道中进行传输。这里就需要使用到Netty的解码器和编码器。 Decoder原理和使用 原理 Netty中的解码器都直接或间接地实现了入站处理适配器，所以在使用时，直接继承解码器就行，而不需要再去实现处理适配器。 在继承解码器的时候需要重写decode方法（在父类中是个抽象方法），在decode方法里实现具体的解码过程。Net
JVM常用参数设置
08-03
本文将深入探讨JVM的常用参数设置，以及它们如何影响Java应用程序的运行。 一、JVM内存设置 1. **堆内存**： - `-Xms`：初始堆大小，例如`-Xms256m`表示初始分配256MB内存。 - `-Xmx`：最大堆大小，例如`-Xmx...
jmilktea#jmilktea#jvm常用参数1
07-25
参数 | 解释内存类|-Xss: | 指定线程栈大小，默认是1M-Xms: | 指定jvm初始堆大小-Xmx: | 指定jvm最大可用内存-Xmn：| 设置新生
Java Thread.Sleep()具有什么功能呢？
qq_25073223的博客
08-08 1711
Java Thread.Sleep()的功能简介说明
ZooKeeper之Java客户端API使用—读取数据。
孤芳不自赏
12-11 1728
博文中的内容来源《从Paxos到Zookeeper 分布式一致性原理与实践》这一本书，感激不尽。
JVM调优：-XX:+PrintCommandLineFlags 查看程序使用的默认JVM参数
学亮编程手记
04-29 6401
java面试中（多线程，高并发）
仓小小鼠
03-10 237
前言：关于java的招聘的相关知识有太多太多，本人之气那简单的过来一遍javaSE的基础知识，但是还是有很多地方没有弄的很清楚，因此这些对之前学习的知识进行一次整理。 java实现多线程的方式 通过继承Thread的方式实现 废话不多说看代码 //这里采用继承thread的方式实现多线程的操作 //这里需要实现对类的run方法的重写 @Override public void run() { System.out.println("this is threa.
java性能调优寻找瓶颈常用的命令_Java性能调优：利用VisualVM进行性能分析
weixin_30768103的博客
02-28 327
JVisualVM 简介VisualVM 是Netbeans的profile子项目，已在JDK6.0 update 7 中自带，能够监控线程，内存情况，查看方法的CPU时间和内存中的对 象，已被GC的对象，反向查看分配的堆栈(如100个String对象分别由哪几个对象分配出来的)。在JDK_HOME/bin(默认是C:\Program Files\Java\jdk1.6.0_13\bin)目录下面...
JAVA线程基础知识-线程池
WangXiong的博客
04-11 156
1、什么是线程池
idea通过PrintCommandLineFlags无法显示默认GC收集
NULL
01-11 607
通过命令 java -XX:+PrintCommandLineFlags -version 结果 JDK1.8无法显示 UseParallelGC (并行GC) 原因是JDK版本是 32位,默认是client模式,所以无法显示垃圾收集器 解决办法 1),通过 java -version 命名查看jdk的版本 2),重新下载新的jdk的64位版本 ,然后重新执行上面的命令,这样就解决了问题 ...
jvm在线分析工具
huashetianzu的专栏
12-17 7591
分享三个实用的在线分析工具： http://www.fastthread.io http://gceasy.io http://heaphero.io
JVM中的Xms和Xmx
热门推荐
legendaryhaha的博客
08-08 3万+
JVM内存参数-Xms和-Xmx 参考资料：(1) JVM常用内存参数配置 (2)深入理解Java虚拟机 -Xms和-Xmx （1）这两个参数老是搞混，特地记一下。-Xms 为JVM启动时申请的初始Heap值，默认为操作系统物理内存的1/64但小于1G。默认当空余堆内存大于70%时，JVM会减小heap的大小到-Xms指定的大小，可通过-XX:MaxHeapFreeRation来指定这个比列。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值