精华内容
下载资源
问答
  • JVM内存分配参数

    2017-06-22 00:10:49
    JVM内存分配参数 1、设置最大堆内存 Java堆最大堆内存可以使用-Xmx 参数指定。最大堆指的是新生代和老年代的大小之和的最大值。即堆上限。 2、设置最小堆内存 Java堆最小堆内存可以使用-Xms 参数指定。最小堆指...

    JVM内存分配参数

    1、设置最大堆内存

    Java堆最大堆内存可以使用-Xmx 参数指定。最大堆指的是新生代和老年代的大小之和的最大值。即堆上限。

    2、设置最小堆内存

    Java堆最小堆内存可以使用-Xms 参数指定。最小堆指的是JVM启动时初始化的堆内存大小。即堆下限。

    通常将最大堆内存和最小堆内存设置相同的大小,因为JVM会尽可能的维护最小堆内存,所以前期会发生频繁的GC已维持最小堆内存大小,当GC后无法满足需求,则会向扩大堆内存。

    3、设置新生代

     -Xmn可以设置新生代大小。由于Java堆由新生代和老年代组成,所以增大新生代会减小老年代。新生代一般设置为整个堆空间1/4到1/3左右。

    4、设置方法区

    方法区也叫持久代,它并不属于堆空间。使用-XX:PermSize可以设置方法区的大小,-XX:MaxPermSize可以设置方法区的最大值。

    方法区的大小决定了系统可以支持多少个类定义和常量。使用CGLIB或者Javassist等动态字节码生成工具,设置合理的方法区大小有助于维持系统稳定。

    通常MaxPermSize设置为64M可以满足绝大部分应用需求,如果依然出去方法区溢出,则可以调整为128M。这两个是很常用的方法区取值。如果128M还满足不了需求,通常应该考虑优化系统设计了。

    5、设置线程栈

    线程栈是线程的私有空间。可通过-Xss设置线程栈大小。

    线程栈太小会导致线程没有足够的空间分配局部变量或达不到足够的函数调用深度,使程序异常退出。而线程栈过大,会加大线程的内存成本,减少系统支持的线程总数。系统支持的线程数大小还和堆大小有关。

    6、设置堆的比例分配

    6.1、新生代中eden和s0比例

    -XX:SurvivorRatio可以设置eden和s0、s1空间的比例关系。

    -XX:SurivorRatio=eden/s0=eden/s1。

    假设-Xmn=10M,-XX:SurvivorRatio=8,则8x(eden)+x(s0)+x(s1)=10,x=1,即s0=s1=1,eden=10。

    6.1、设置新生代和老年代的比例

    -XX:NewRatio可以设置新生代和老年代的比例。

    -XX:NewRatio=老年代 / 新生代。

    堆空间=新生代+老年代

    假设-Xmx=-Xms=12M、-XX:NewRatio=2M,则 新生代=12*1/3=4M,老年代=12-4=8M。

     

     

    参考:

    《Java程序性能优化  让你的Java程序更快、更稳定》

     

    展开全文
  • JVM内存分配参数通常是针对堆来说的,因为 java堆是垃圾收集器(GC)管理的主要区域,是Java虚拟机所管理的内存中最大的一块。 整个堆大小=新生代 + 老年代 + 持久代(相对于HotSpot 类型的虚拟机) 目录 1、-...

    JVM内存分配参数通常是针对堆来说的,因为 java堆是垃圾收集器(GC)管理的主要区域,是Java虚拟机所管理的内存中最大的一块。

    整个堆大小=新生代 + 老年代 + 持久代(相对于HotSpot 类型的虚拟机)

    目录

    1、-Xmx:设置最大堆空间

    2、-Xms:设置最小堆内存

    3、-Xmn:设置新生代大小

    4、设置持久代

    5、堆的比例分配

    附:完整参数列表


    1、-Xmx:设置最大堆空间

    最大堆空间是指新生代和老年代的大小之和的最大值

    我们来测试一下

    import java.util.Vector;
    
    public class MaxHeap {
    	public static void main(String[] args) {
    		System.out.println("最大内存"+Runtime.getRuntime().maxMemory()/1024/1024+"M");
    		Vector v=new Vector();
    		for(int i=0;i<10;i++){
    			byte[] b=new byte[1024*1024]; //分配1M
    			v.add(b); //强引用,GC不能释放空间
    			System.out.println((i+1)+"M 空间被分配");
    		}
    	}
    }
    

    运行结果

    最大内存247M
    1M 空间被分配
    2M 空间被分配
    3M 空间被分配
    4M 空间被分配
    5M 空间被分配
    6M 空间被分配
    7M 空间被分配
    8M 空间被分配
    9M 空间被分配
    10M 空间被分配

    可见本机默认的最大堆内存空间为247M,10M空间也被正常分配了

    接下来我们来通过Xmx参数来修改最大堆空间

    在菜单栏选择 Run->Run Configurations

    运行结果

    2、-Xms:设置最小堆内存

    最小堆内存即当JVM启动的时候占有的操作系统内存大小的最小值。

    java程序在运行时首先分配最小堆内存的内存大小,然后尽可能地尝试在这个空间内运行程序,如果设置的最小堆内存的大小不能满足应用程序时,JVM会向操作系统提出申请堆空间,直到达到最大堆内存大小位置,如果超出了最大堆内存大小,会抛出OOM异常。

    如果说最小堆内存设置得太小了,垃圾收集就会频繁地去操作,用于释放失效的内存空间,会对性能有一定的影响。所以最小堆内存空间大小要由具体应用程序来决定。

    我们来测试一下:

    import java.util.Vector;
    
    public class MinHeap {
    	public static void main(String[] args) {
    		System.out.println("最大内存"+Runtime.getRuntime().maxMemory()/1024/1024+"M");
    		Vector v=new Vector();
    		for(int i=0;i<10;i++){
    			byte[] b=new byte[1024*1024*10]; //分配10M
    			v.add(b); //强引用,GC不能释放空间
    			if(v.size()==3){
    				v.clear(); //清空内存
    			}
    			System.out.println("-------");
    		}
    	}
    }

    参数设置:最小堆内存为10M,-XX:+PrintGCDetails表示打印GC的详细信息,默认最大堆内存空间为247M

    运行结果

    最大内存247M
    [GC [DefNew: 624K->320K(3072K), 0.0027563 secs][Tenured: 75K->395K(6848K), 0.0070076 secs] 624K->395K(9920K), [Perm : 149K->149K(12288K)], 0.0098816 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
    ---
    [GC [DefNew: 112K->0K(3136K), 0.0004821 secs][Tenured: 20875K->20876K(27332K), 0.0058795 secs] 20988K->20876K(30468K), [Perm : 149K->149K(12288K)], 0.0065446 secs] [Times: user=0.02 sys=0.00, real=0.01 secs] 
    ---
    [GC [DefNew: 0K->0K(15680K), 0.0004476 secs][Tenured: 41356K->41356K(55280K), 0.0051294 secs] 41356K->41356K(70960K), [Perm : 149K->149K(12288K)], 0.0057963 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
    ---
    [GC [DefNew: 20480K->0K(31104K), 0.0004693 secs] 61836K->41356K(100032K), 0.0005124 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
    ---
    [GC [DefNew: 20480K->0K(31104K), 0.0185877 secs] 61836K->61836K(100032K), 0.0186214 secs] [Times: user=0.01 sys=0.00, real=0.02 secs] 
    ---
    [GC [DefNew: 20480K->0K(31104K), 0.0211021 secs][Tenured: 82316K->41355K(89412K), 0.0150908 secs] 82316K->41355K(120516K), [Perm : 149K->149K(12288K)], 0.0380787 secs] [Times: user=0.03 sys=0.00, real=0.04 secs] 
    ---
    [GC [DefNew: 20480K->0K(31104K), 0.0004966 secs] 61835K->41355K(100032K), 0.0005308 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
    ---
    [GC [DefNew: 20480K->0K(31104K), 0.0039629 secs] 61835K->61835K(100032K), 0.0039979 secs] [Times: user=0.02 sys=0.00, real=0.00 secs] 
    ---
    [GC [DefNew: 20480K->0K(31104K), 0.0136943 secs][Tenured: 82315K->41355K(89412K), 0.0131430 secs] 82316K->41355K(120516K), [Perm : 149K->149K(12288K)], 0.0284924 secs] [Times: user=0.03 sys=0.00, real=0.03 secs] 
    ---
    [GC [DefNew: 20480K->0K(31104K), 0.0005393 secs] 61835K->41355K(100032K), 0.0006814 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
    ---
    Heap
     def new generation   total 31104K, used 21034K [0x24fe0000, 0x27190000, 0x2a530000)
      eden space 27712K,  75% used [0x24fe0000, 0x2646a9d0, 0x26af0000)
      from space 3392K,   0% used [0x26e40000, 0x26e40000, 0x27190000)
      to   space 3392K,   0% used [0x26af0000, 0x26af0000, 0x26e40000)
     tenured generation   total 68928K, used 41355K [0x2a530000, 0x2e880000, 0x34fe0000)
       the space 68928K,  59% used [0x2a530000, 0x2cd92f80, 0x2cd93000, 0x2e880000)
     compacting perm gen  total 12288K, used 149K [0x34fe0000, 0x35be0000, 0x38fe0000)
       the space 12288K,   1% used [0x34fe0000, 0x35005420, 0x35005600, 0x35be0000)
        ro space 10240K,  45% used [0x38fe0000, 0x39467290, 0x39467400, 0x399e0000)
        rw space 12288K,  54% used [0x399e0000, 0x3a06ace8, 0x3a06ae00, 0x3a5e0000)
    

    当把最小堆内存空间值设大,比如100M:

    运行结果

    最大内存247M
    ---
    ---
    [GC [DefNew: 21573K->395K(30720K), 0.0189547 secs] 21573K->20875K(99008K), 0.0192922 secs] [Times: user=0.02 sys=0.00, real=0.02 secs] 
    ---
    ---
    [GC [DefNew: 21709K->395K(30720K), 0.0096141 secs] 42189K->31115K(99008K), 0.0096482 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
    ---
    ---
    [GC [DefNew: 21065K->395K(30720K), 0.0010500 secs] 51785K->31115K(99008K), 0.0010871 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
    ---
    ---
    [GC [DefNew: 21000K->395K(30720K), 0.0187759 secs] 51720K->51595K(99008K), 0.0188122 secs] [Times: user=0.02 sys=0.00, real=0.02 secs] 
    ---
    ---
    Heap
     def new generation   total 30720K, used 21504K [0x24fe0000, 0x27130000, 0x2a530000)
      eden space 27328K,  77% used [0x24fe0000, 0x2647d418, 0x26a90000)
      from space 3392K,  11% used [0x26a90000, 0x26af2f60, 0x26de0000)
      to   space 3392K,   0% used [0x26de0000, 0x26de0000, 0x27130000)
     tenured generation   total 68288K, used 51200K [0x2a530000, 0x2e7e0000, 0x34fe0000)
       the space 68288K,  74% used [0x2a530000, 0x2d730050, 0x2d730200, 0x2e7e0000)
     compacting perm gen  total 12288K, used 149K [0x34fe0000, 0x35be0000, 0x38fe0000)
       the space 12288K,   1% used [0x34fe0000, 0x35005448, 0x35005600, 0x35be0000)
        ro space 10240K,  45% used [0x38fe0000, 0x39467290, 0x39467400, 0x399e0000)
        rw space 12288K,  54% used [0x399e0000, 0x3a06ace8, 0x3a06ae00, 0x3a5e0000)

    可见,GC运行次数明显少了

    JVM会试图将系统内存尽可能限制在-Xms中,当内存实际使用量触及到了-Xms大小时,会触发FullGC

    如果-Xms值比较大时,系统在运行的初期可以减少垃圾收集的次数和耗时

    3、-Xmn:设置新生代大小

    新生代的内存大小会影响老年代的内存大小,因为他们俩所占的最大堆空间是一定的。一般新生代的大小设置为整个堆的1/4~1/3

    等价于hot spot:-XX:NewSize 新生代初始大小 和 -XX:MaxNewSize

    import java.util.Vector;
    
    public class testHeap {
    	public static void main(String[] args) {
    		System.out.println("最大内存"+Runtime.getRuntime().maxMemory()/1024/1024+"M");
    		Vector v=new Vector();
    		for(int i=0;i<10;i++){
    			byte[] b=new byte[1024*1024]; //分配10M
    			v.add(b); //强引用,GC不能释放空间			
    			if(v.size()==3){
    				v.clear(); //清空内存
    			}
    			System.out.println("---");
    		}
    	}
    }

    运行结果

    最大内存9M
    ---
    ---
    [GC [DefNew: 2662K->384K(3712K), 0.0040951 secs] 2662K->2444K(9856K), 0.0041638 secs] [Times: user=0.00 sys=0.02, real=0.01 secs] 
    ---
    ---
    ---
    [GC [DefNew: 3562K->0K(3712K), 0.0030396 secs] 5622K->4492K(9856K), 0.0030754 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
    ---
    ---
    ---
    [GC [DefNew: 3098K->3098K(3712K), 0.0000183 secs][Tenured: 4492K->2444K(6144K), 0.0052126 secs] 7590K->2444K(9856K), [Perm : 149K->149K(12288K)], 0.0052851 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
    ---
    ---
    Heap
     def new generation   total 3712K, used 2132K [0x345e0000, 0x349e0000, 0x349e0000)
      eden space 3328K,  64% used [0x345e0000, 0x347f5030, 0x34920000)
      from space 384K,   0% used [0x34920000, 0x34920000, 0x34980000)
      to   space 384K,   0% used [0x34980000, 0x34980000, 0x349e0000)
     tenured generation   total 6144K, used 2444K [0x349e0000, 0x34fe0000, 0x34fe0000)
       the space 6144K,  39% used [0x349e0000, 0x34c43010, 0x34c43200, 0x34fe0000)
     compacting perm gen  total 12288K, used 149K [0x34fe0000, 0x35be0000, 0x38fe0000)
       the space 12288K,   1% used [0x34fe0000, 0x35005448, 0x35005600, 0x35be0000)
        ro space 10240K,  45% used [0x38fe0000, 0x39467290, 0x39467400, 0x399e0000)
        rw space 12288K,  54% used [0x399e0000, 0x3a06ace8, 0x3a06ae00, 0x3a5e0000)

    可见一共调用了2次GC以及1次fullgc

    我们调大新生代大小为6M时

    最大内存9M
    ---
    ---
    ---
    ---
    [GC [DefNew: 4792K->396K(5568K), 0.0035639 secs] 4792K->1420K(9664K), 0.0036134 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
    ---
    ---
    ---
    ---
    [GC [DefNew: 4648K->0K(5568K), 0.0029615 secs] 5672K->3468K(9664K), 0.0030003 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
    ---
    ---
    Heap
     def new generation   total 5568K, used 2185K [0x345e0000, 0x34be0000, 0x34be0000)
      eden space 4992K,  43% used [0x345e0000, 0x34802428, 0x34ac0000)
      from space 576K,   0% used [0x34ac0000, 0x34ac0088, 0x34b50000)
      to   space 576K,   0% used [0x34b50000, 0x34b50000, 0x34be0000)
     tenured generation   total 4096K, used 3467K [0x34be0000, 0x34fe0000, 0x34fe0000)
       the space 4096K,  84% used [0x34be0000, 0x34f42f98, 0x34f43000, 0x34fe0000)
     compacting perm gen  total 12288K, used 149K [0x34fe0000, 0x35be0000, 0x38fe0000)
       the space 12288K,   1% used [0x34fe0000, 0x35005448, 0x35005600, 0x35be0000)
        ro space 10240K,  45% used [0x38fe0000, 0x39467290, 0x39467400, 0x399e0000)
        rw space 12288K,  54% used [0x399e0000, 0x3a06ace8, 0x3a06ae00, 0x3a5e0000)
    

    只进行了2次GC

    4、设置持久代

    持久代不属于堆的一部分,持久代的大小直接决定了系统可以支持多少类定义和多久常量。

    -XX:PermSize:设置持久代的初始大小

    -XX:MaxPermSize:设置持久代的最大值

    5、堆的比例分配

    一、-XX:SurvivorRatio 设置新生代中的eden空间与s0(from),s1(to)之间的比例关系

    因为s0与s1大小是相等的,它们不过是在每次gc后会交换角色,所以-XX:SurvivorRatio=eden/s0=eden/s1

    比如:

    可见 eden/from=8192/1024=8

    Heap
     def new generation   total 9216K, used 891K [0x24fe0000, 0x259e0000, 0x259e0000)
      eden space 8192K,  10% used [0x24fe0000, 0x250befc0, 0x257e0000)
      from space 1024K,   0% used [0x257e0000, 0x257e0000, 0x258e0000)
      to   space 1024K,   0% used [0x258e0000, 0x258e0000, 0x259e0000)
     tenured generation   total 6144K, used 0K [0x259e0000, 0x25fe0000, 0x34fe0000)
       the space 6144K,   0% used [0x259e0000, 0x259e0000, 0x259e0200, 0x25fe0000)
     compacting perm gen  total 12288K, used 148K [0x34fe0000, 0x35be0000, 0x38fe0000)
       the space 12288K,   1% used [0x34fe0000, 0x35005180, 0x35005200, 0x35be0000)
        ro space 10240K,  45% used [0x38fe0000, 0x39467290, 0x39467400, 0x399e0000)
        rw space 12288K,  54% used [0x399e0000, 0x3a06ace8, 0x3a06ae00, 0x3a5e0000)
    

    二、-XX:NewRatio:设置老年代与新生代比例

     

    附:完整参数列表

    来自于https://blog.csdn.net/wang379275614/article/details/78471604

    JVM参数

    并行收集器相关

    CMS相关

    辅助信息

     

    展开全文
  • JVM调优由浅到深(四)——JVM内存分配参数详解常用参数设置设置最大堆内存设置最小堆内存设置新生代设置持久代设置线程栈堆的内存分配堆分配参数总结 我们在这一篇文章中已经大概了解到了jvm的参数有哪些,大概怎么...

    我们在这一篇文章中已经大概了解到了jvm的参数有哪些,大概怎么设置。
    JVM调优由浅到深(一)——jvm参数配置

    现在我们再来详细得再更加详细分析一次;

    常用参数设置

    设置最大堆内存

    参数说明 例子
    最大堆内存 -Xmx10m

    在运行时,可以使用 Runtime.getRuntime().maxMemory() 取得系统可用的最大堆内存。

        public void test5(){
            System.out.println(Runtime.getRuntime().maxMemory()/1024/1024);
        }
    

    运行结果:

    设置最小堆内存

    参数说明 例子
    最小堆内存 -Xms10m

    Java应用程序在运行时,首先被分配-Xms指定的内存大小,并尽可能尝试在这个空间段内运行程序。
    当-Xms指定的内存大小确实无法满足应用程序时,JVM 才会向操作系统申请更多的内存,直到内存大小达到-Xmx指定的最大内存为止。
    若超过-Xmx的值,则抛出 OutOfMemoryError 异常。

    如果 -Xms 的数值较小,那么JVM为了保证系统尽可能地在指定内存范围内运行,就会更加频繁地进行GC操作,以释放失效的内存空间。
    从而,会增加 Minor GC 和 Full GC的次数,对系统性能产生一定的影响
    因此把 -Xms 值设置为 -Xmx 时,可以在系统运行初期减少 GC 的次数和耗时。

    设置新生代

    参数说明 例子
    新生代 -Xmn2m

    设置一个较大的新生代会减少老年代的大小,这个参数对系统性能以及 GC 行为有很大的影响。
    新生代的大小一般设置为整个堆空间的1/4到1/3左右。

    在 Hot Spot 虚拟机中,-XX:NewSize 用于设置新生代的初始大小,
    -XX:MaxNewSize用于设置新生代的最大值。
    但通常情况下,只设置 -Xmn 以及可以满足绝大部分应用的需要。
    设置 -Xmn 的效果等同于设置了相同的-XX:NewSize 和 -XX:MaxNewSize。

    若设置不同的-XX:NewSize 和 -XX:MaxNewSize可能会导致内存震荡,从而产生不必要的系统开销。

    设置持久代

    持久代(方法区)不属于Java堆的一部分。在Hot Spot虚拟机中,使用-XX:MaxPermSize可以设置持久代的最大值,使用-XX:PermSize可以设置持久代的初始大小。

    JDK1.8取消了PermGen,取而代之的是Metaspace(元空间),
    所以PermSize和MaxPermSize参数失效,取而代之的是 -XX:MetaspaceSize
    和 -XX:MaxMetaspaceSize。

    参数说明 例子
    持久代的初始大小 -XX:MetaspaceSize=64M
    持久代的最大值 -XX:MaxMetaspaceSize=128M

    持久代的大小直接决定了系统可以支持多少个类定义和多少常量。
    对于使用 CGLIB 或者 Javassist 等动态字节码生成工具的应用程序而言,
    设置合理的持久代大小有助于维持系统稳定。

    一般来说,设置MaxMetaspaceSize为64MB已经可以满足绝大部分应用程序正常工作。
    如果依然出现永久区溢出,可以将MaxMetaspaceSize设置为128MB。
    这是两个很常用的永久区取值。

    设置线程栈

    线程栈是线程的一块私有空间。有关描述可以参考前文的“Java虚拟机栈”。

    参数说明 例子
    线程栈大小 -Xss1M

    在线程中进行局部变量分配,函数调用时,都需要在栈中开辟空间。

    如果栈的空间分配太小,那么线程在运行时,可能没有足够的空间分配局部变量或者达不到足够的函数调用深度,导致程序异常退出;

    如果栈空间过大,那么开设线程所需的内存成本就会上升,系统所能支持的线程总数就会下降。

    由于Java堆也是向操作系统申请内存空间的,
    因此,如果堆空间过大,就会导致操作系统可用于线程栈的内存减少,
    从而间接减少程序所能支持的线程数量。

    当系统由于内存不够无法创建新的线程时,会抛出 OOM 异常如下:

    java.lang.OutOfMemoryError: unable to create new native thread
    

    根据以上内容可知,这并不是由于堆内存不够而导致的 OOM,而是因为操作系统内存减去堆内存后,剩余的系统内存不足而无法创建新的线程。

    在这种情况下,可以尝试减少堆内存,以换取更多的系统空间,来解决这个问题。

    如果系统确实需要大量的线程并发执行,那么设置一个较小的堆和较小的栈,
    有助于提供系统所能承受的最大线程数。

    堆的内存分配

    参数说明 例子
    eden区/survivor区 -XX:SurvivorRatio=8
    老年代/新生代 -XX:NewRatio=2

    参数 -XX:SurvivorRatio 是用来设置新生代中,eden空间和s0空间的比例关系。
    s0 和 s1 空间又被称为 from 空间和 to 空间。
    它们的大小是相同的,职能也是一样的,并在 Minor GC后,会互换角色。

    公式:-XX:SurvivorRatio = eden/s0 = eden/s1

    举例:当设置JVM参数 -Xmn10M -XX:SurvivorRatio=8 就等于设置 eden=8M,s0=1M,s1=1M。

    参数 -XX:NewRatio 是用来设置新生代与老年代的比例:

    公式:-XX:NewRatio = 老年代 / 新生代

    举例:当设置JVM参数 -Xms18M -Xmx18M -XX:NewRatio=2运行程序时,新生代约占6MB,老年代约占12MB。

    堆分配参数总结

    参数说明 例子
    -Xmx 设置Java应用程序能获得的最大堆
    -Xms 设置Java应用程序启动时的初始堆
    -Xss 设置新生代的初始大小与最大值
    -Xmn 设置新生代的初始大小与最大值
    -XX:NewSize 设置新生代的大小。
    -XX:NewRatio 设置老年代与新生代的比例,它等于老年代大小除以新生代大小。
    -XX:SurvivorRatio 设置新生代中eden区和survivor区的比例
    -XX:MetaspaceSize XX
    -XX:MetaspaceSize (Java8)设置永久区的初始值。。
    -XX:MaxMetaspaceSize (Java8)最大的持久区大小。
    -XX:MinHeapFreeRatio 设置堆空间的最大空闲比例,当堆空间的空闲内存小于这个数值时,JVM便会扩展堆空间
    -XX:MaxHeapFreeRatio 设置堆空间的最大空闲比例。当堆空间的空闲内存大于这个数值时,便会压缩堆空间,得到一个较小的堆。
    -XX:TargetSurvivorRatio 设置survivor区的可使用率。当survivor区的空间使用率达到这个值时,会将对象送入老年代。

    非常感谢以下博主的优秀博客

    https://www.cnblogs.com/yueshutong/p/9768298.html

    展开全文
  • JVM内存分配参数对程序性能的影响,包括设置最大堆和设置最小堆

    文章首发在https://www.amoshuang.com/archives/1901


    使用IDEA的小伙伴可以在Run -> Edit Configurations 设置VM options属性来设置JVM参数: ![](https://www.amoshuang.com/wp-content/uploads/2018/12/设置JVM参数.png)

    1. 设置最大堆

    使用-Xmx参数可以指定Java应用程序的最大堆。最大堆为新生代和老年代的大小纸盒的最大值,是Java程序的堆上限。

    使用如下代码进行测试,每次循环将会向容器v中增加1M的数据。

    public class TestXmx {
      public static void main(String args[]){
      	Vector v=new Vector();
      	for(int i=1;i&lt;=10;i++){
      		byte[] b=new byte[1024*1024];
      		v.add(b);             //强引用,GC不能释放空间
      		System.out.println(i+"M is allocated");
      	}
      	System.out.println("Max memory:"+Runtime.getRuntime().maxMemory()/1024/1024+"M");
      }
    }
    

    当使用参数-Xmx11M进行运行时,程序可以顺利结束并且没有任何异常。但当使用参数-Xmx5M进行运行时,则会报OutOfMemoryError错误。

    在运行时,可以使用Runtime.getRuntime().maxMemory()方法获取最大堆内存。

    2.设置最小堆内存

    使用参数-XMS 可以用于设置系统的最小堆空间,也就是JVM启动时所占据的操作空间大小。

    Java应用程序在运行时,首先会分配指定大小的内存大小,并尽可能在这个空间段内运行程序。当-Xms指定的内存大小确实无法满足应用程序时,JVM才会向操作系统申请更多的内存,知道内存大小达到-Xmx指定的大小为止。若超过,则抛出OutOfMemoryError错误。

    如果-Xms太小,则会导致JVM为了保证系统尽可能可以在指定内存范围内运行而频繁进行GC操作,以释放失效的内存空间,从而对系统性能产生影响。

    注意:将-XmS值设置为-Xmx的值,可以减少在系统运行初期GC的次数和耗时。

    展开全文
  • JVM内存分配参数对程序性能的影响(二),包括设置新生代、持久代以及线程栈
  • 设置最大堆内存 ...使用-Xms可以设置系统的最小堆空间,也就是jvm启动时,所占据的操作系统的内存大小。 设置新生代 设置持久代   设置线程栈 ---------------------  作者:代码...
  • 主要的JVM内存参数: -Xms:设置Java应用程序启动时的初始堆大小 -Xmx:设置Java应用程序能获得的最大堆大小 -Xss:设置线程栈大小 -XX:MinHeapFreeRatio:设置堆空间最小空闲比例。当堆空间的空闲内存小于这个...
  • 1.先简单介绍如何配置 ...注:上面的配也可以直接在计算机中设置,如windows环境下可以在环境变量中设置如上参数,设置完毕后就是全局参数(需要重启电脑)。如果需要设置其他相关选项,可以在J...
  • 优化JVM内存分配

    2021-05-08 10:55:18
    JVM 调优是一个系统而又复杂的过程,但我们知道,在大多数情况下,我们基本不用去调整 JVM 内存分配,因为一些初始化的参数已经可以保证应用服务正常稳定地工作了。 但所有的调优都是有目标性的,JVM 内存分配调优...
  • 下面会介绍几条最普遍的内存分配规则。以上是JVM内存分布情况,内存分为新生代和老年代,以及元数据区域。新生代则分为一块较大的Eden空间(80%)和两块小的Servivor(各占10%)。我们一般new Obje...
  • JVM内存分配

    2021-03-18 10:07:51
    我们知道在jvm内存模型中,分为堆、虚拟机栈、方法区、本地方法栈、程序计数器,其中堆又分为新生代和老年代,那么对象的在堆是如何分配呢? 1.新生代内存分配 新生代分为eden space,from space和to space三个...
  • JVM内存分配规则

    2020-12-01 16:55:24
    JVM内存分配规则 堆内存分配: JDK8 默认的,新生代(Young)与老年代的比例值为 1:2(该值可以通过参数 -XX:NewRatio来指定)。 新生代分为 Eden和两个Survior区域,分别被命名为from和to,以示区分。 默认的,...
  • 概述java内存溢出之后,我们需要根据错误信息分析一下内存溢出的具体原因,及时调整中间件的参数、查看jvm内存分配linux下可以通过jmap -heap 【pid】命令查看jvm的内存分配例如:jmap -heap 1此图可以看出...
  • JVM内存管理分为两部分: 内存分配 内存回收 ------------------------------------------------------ 内存回收经常也被叫做垃圾回收。(附带资料:JVM面试题超链接、JVM性能调优和 参数说明) *很多人迷惑一...
  • JVM 调优是一个系统而又复杂的过程,但我们知道,在大多数情况下,我们基本不用去调整 JVM 内存分配,因为一些初始化的参数已经可以保证应用服务正常稳定地工作了。 但所有的调优都是有目标性的,JVM 内存分配调优...
  • 四、Jvm内存分配

    2021-02-28 23:13:09
    Java虚拟机——》Jvm内存分配 什么是JVM内存分配呢? 就是当我们创建一个对象的时候,要在JVM内存空间里为这个对象分配一些空间,来存放对象的一些属性信息。 对象创建的流程 1)类加载检查 在创建对象的...
  • JVM内存分配设置

    2014-09-05 15:57:03
    安装Java开发软件时,默认安装包含两个文件夹,一个JDK(Java开发工具箱),一个JRE(Java运行环境,...1. JVM内存分配设置的参数有四个: -Xmx Java Heap最大值,默认值为物理内存的1/4,最佳设值应该视物理内存大小
  • 程序计数器:它是一块较小的内存空间,主要作用是当前线程所执行的字节码的行号指示器.由于java虚拟机的多线程是通过轮流切换并分配处理器执行时间的方式来实现的(协作式/抢占式?!),即任何时刻,任一CPU只会正在处理一...
  • JVM内存分配 策略

    2020-07-10 10:25:39
    Java 提供的自动内存管理,可以归结为解决了对象的内存分配和回收的问题。 前面已经介绍了内存回收,下面介绍几条最普遍的内存分配策略: ①对象优先在 Eden 区分配:大多数情况下,对象在先新生代 Eden 区中分配...
  • 设置JVM内存参数有四个:-Xmx Java Heap***值,默认值为物理内存的1/4,***设值应该视物理内存大小及计算机内其他内存开销而定;-Xms Java Heap初始值,Server端JVM***将-Xms和-Xmx设为相同值,开发测试机JVM可以...
  • 配置JVM内存分配

    2012-10-20 14:59:30
    你知道如何配置JVM内存分配吗,这里和大家分享几个妙招,安装Java开发软件时,默认安装包含两个文件夹,一个JDK(Java开发工具箱),一个JRE(Java运行环境,内含JVM),其中JDK内另含一个JRE。如果只是运行Java程序,则...
  • JVM 内存分配和回收策略 1. 前言 对象的内存分配往大方向讲,就是在堆上分配内存。对象主要分配在新生代...对于JVM内存区域不了解的同学可以看这里Java内存区域分配和GC。 之后我们通过代码验证下这些规则,我安装...
  • 本文是为大家精心整理JVM内存分配、垃圾收集器和常用参数这三方面的知识点,希望大家能熟练掌握好jvm的基础知识点,为成为优秀的程序猿打下坚实的基础。 熟练掌握jvm的基础知识是作为java程序猿必需掌握的,这...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,885
精华内容 1,154
关键字:

jvm内存分配参数