精华内容
下载资源
问答
  • 城市化进程中新生代农民工定居城市意愿影响因素分析,汪杭,张敬华,本文选取2000-2010年新生代农民工流入量作为研究样本,实证研究了城市化进程中一些主要因素对新生代农民工定居城市意愿的影响。结果
  • 鄂尔多斯盆地东南缘大宁-吉县地区煤层气资源丰富,对该区成煤后中新生代构造及其演化的认识,有利于煤层气勘探与开发的有效开展。基于区域构造演化特征,运用构造地质学的研究方法,对该区勘查资料和野外节理测量数据...
  • 从火山活动至沉积建造的多旋回特点出发,系统论述了冀西北地区中新生代盆地的成生与演化发展,对不同时期盆地的特征进行了分析总结。①区内中生代的构造变动以断裂和局部升降、局部褶皱为主,形成了一系列断陷盆地和...
  • 二连盆地中新生代经历了复杂的发育历史,是一个多期叠加的盆地系统,它经历了早侏罗世-中侏罗世-伸展断陷盆地期、晚侏罗世末-区域性构造反转期、早白垩世早中期-强烈断陷盆地期、早白垩世晚期-晚白垩世-盆地南东部抬升...
  • 今天看了下Jvm中新生代和老年代的定义和解析,然后看到一篇博,把自己整懵了,还好后面应该是懂了。 首先是我看到的关于新生代和老年代相关的部分 转自https://www.cnblogs.com/gaopengfirst/p/10037887.html ...

    今天看了下Jvm中新生代和老年代的定义和解析,然后看到一篇博,把自己整懵了,还好后面应该是懂了。

    • 首先是我看到的关于新生代和老年代相关的部分

    转自https://www.cnblogs.com/gaopengfirst/p/10037887.html

    3.1.1 新生代:

    分为三部分:1个Eden区和2个Survivor区(分别叫from和to)。默认比例为8:1。一般情况下,新创建的对象都会被分配到Eden区(一些大对象特殊处理),这些对象经过第一次Minor GC后,如果仍然存活,将会被移到Survivor区。对象在Survivor区中每熬过一次Minor GC,年龄就会增加1岁,当它的年龄增加到一定程度时,就会被移动到年老代中。

    因为年轻代中的对象基本都是朝生夕死的(80%以上),所以在年轻代的垃圾回收算法使用的是复制算法,复制算法的基本思想就是将内存分为两块,每次只用其中一块,当这一块内存用完,就将还活着的对象复制到另外一块上面。复制算法不会产生内存碎片。

    在GC开始的时候,对象只会存在于Eden区和名为“From”的Survivor区,Survivor区“To”是空的。紧接着进行GC,Eden区中所有存活的对象都会被复制到“To”,而在“From”区中,仍存活的对象会根据他们的年龄值来决定去向。年龄达到一定值(年龄阈值,可以通过-XX:MaxTenuringThreshold来设置)的对象会被移动到年老代中,没有达到阈值的对象会被复制到“To”区域。(动态判断对象的年龄。如果Survivor区中相同年龄的所有对象大小的总和大于Survivor空间的一半,年龄大于或等于该年龄的对象可以直接进入老年代。)经过这次GC后,Eden区和From区已经被清空。这个时候,“From”和“To”会交换他们的角色,也就是新的“To”就是上次GC前的“From”,新的“From”就是上次GC前的“To”。不管怎样,都会保证名为To的Survivor区域是空的。Minor GC会一直重复这样的过程,直到“To”区被填满,“To”区被填满之后,会将所有对象移动到年老代中。

    GC可分为三种:Minor GC Major GC 和 Full GC

    Minor GC :是清理新生代。触发条件:当Eden区满时,触发Minor GC。

    Major GC:是清理老年代。是 Major GC 还是 Full GC,大家应该关注当前的 GC 是否停止了所有应用程序的线程,还是能够并发的处理而不用停掉应用程序的线程

    Full GC :是清理整个堆空间—包括年轻代和老年代。触发条件:调用System.gc时,系统建议执行Full GC,但是不必然执行;老年代空间不足;方法区空间不足;通过Minor GC后进入老年代的平均大小大于老年代的可用内存;由Eden区、From Space区向To Space区复制时,对象大小大于To Space可用内存,则把该对象转存到老年代,且老年代的可用内存小于该对象大小

    3.1.2 老年代:

    主要存放应用程序中生命周期长的内存对象。

    老年代的对象比较稳定,所以MajorGC不会频繁执行。在进行MajorGC前一般都先进行了一次MinorGC,使得有新生代的对象晋身入老年代,导致空间不够用时才触发。当无法找到足够大的连续空间分配给新创建的较大对象时也会提前触发一次MajorGC进行垃圾回收腾出空间。

    MajorGC采用标记—清除算法:首先扫描一次所有老年代,标记出存活的对象,然后回收没有标记的对象。MajorGC的耗时比较长,因为要扫描再回收。MajorGC会产生内存碎片,为了减少内存损耗,我们一般需要进行合并或者标记出来方便下次直接分配。

    当老年代也满了装不下的时候,就会抛出OOM(Out of Memory)异常。

    • 让我一开始没有看明白的文章部分代码

    转自https://blog.csdn.net/java_wxid/article/details/103021907

    import java.lang.management.ManagementFactory;
    import java.lang.management.MemoryMXBean;
    import java.util.ArrayList;
    import java.util.List;
    
    public class TestJvm {
        byte[] a = new byte[1024*1024*1];//1M
    
        public static void main(String[] args) {
                List<Object> list = new ArrayList<Object>();
                int i =1;
                MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
                System.out.println("初始化堆的当前内存使用量:"+memoryMXBean.getHeapMemoryUsage());
                System.out.println("初始化非堆内存的当前内存使用量:"+memoryMXBean.getNonHeapMemoryUsage());
                while (true){
                    list.add(new TestJvm());
                    try {
                        Thread.sleep(40);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
    //            System.out.println("非堆内存的当前内存使用量:"+memoryMXBean.getNonHeapMemoryUsage());
                    System.out.println("堆内存的当前内存使用量:"+memoryMXBean.getHeapMemoryUsage());
                    System.out.println(i++);
                }
            }
    
        }
    
    • 解析

    程序是个死循环,每次运行TestJvm占用内存1m,我主要是想看看这个数据是怎么在新生代和老年代之间走的,下面是输出:

    初始化堆的当前内存使用量:init = 31457280(30720K) used = 976008(953K) committed = 30146560(29440K) max = 30146560(29440K)
    初始化非堆内存的当前内存使用量:init = 23527424(22976K) used = 4016128(3922K) committed = 23527424(22976K) max = 71303168(69632K)
    堆内存的当前内存使用量:init = 31457280(30720K) used = 2190088(2138K) committed = 30146560(29440K) max = 30146560(29440K)
    1
    堆内存的当前内存使用量:init = 31457280(30720K) used = 3238680(3162K) committed = 30146560(29440K) max = 30146560(29440K)
    2
    堆内存的当前内存使用量:init = 31457280(30720K) used = 4287272(4186K) committed = 30146560(29440K) max = 30146560(29440K)
    3
    堆内存的当前内存使用量:init = 31457280(30720K) used = 5335864(5210K) committed = 30146560(29440K) max = 30146560(29440K)
    4
    堆内存的当前内存使用量:init = 31457280(30720K) used = 6384456(6234K) committed = 30146560(29440K) max = 30146560(29440K)
    5
    堆内存的当前内存使用量:init = 31457280(30720K) used = 7433048(7258K) committed = 30146560(29440K) max = 30146560(29440K)
    6

    到这里为止还好,我还能明白,占用的数据都在新生代的Eden区,新生代分为3个区:Eden区和名为“From”的Survivor区,“To”的Survivor区


    [GC [PSYoungGen: 7258K->1248K(8960K)] 7258K->6460K(29440K), 0.0047718 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
    堆内存的当前内存使用量:init = 31457280(30720K) used = 7908112(7722K) committed = 30146560(29440K) max = 30146560(29440K)
    7

    然后开始新生代GC,新生代已使用7258k,GC之后新生代已使用1248k,新生代总大小9M,GC前Java堆已使用容量7258K,GC后Java堆已使用容量6460K,总堆的大小29M。

    Eden区中所有存活的对象都会被复制到“To”,结果就是在To,放不下的进入了老年代。

    经过这次GC后,Eden区和From区已经被清空。这个时候,“From”和“To”会交换他们的角色,也就是新的“To”就是上次GC前的“From”,新的“From”就是上次GC前的“To”。不管怎样,都会保证名为To的Survivor区域是空的。Minor GC会一直重复这样的过程,直到“To”区被填满,“To”区被填满之后,会将所有对象移动到年老代中。也就是Full CG

    上面都是1M1次增加占用,垃圾回收以后变成增加了0.5M,我都对象都在使用中,不可能会被垃圾释放掉,我的这些内存跑哪里区了呢?

    最后我只能认为,真的是释放了点垃圾吧,具体什么垃圾我是真的没有想明白。 


    堆内存的当前内存使用量:init = 31457280(30720K) used = 8956704(8746K) committed = 30146560(29440K) max = 30146560(29440K)
    8
    堆内存的当前内存使用量:init = 31457280(30720K) used = 10005296(9770K) committed = 30146560(29440K) max = 30146560(29440K)
    9
    堆内存的当前内存使用量:init = 31457280(30720K) used = 11053888(10794K) committed = 30146560(29440K) max = 30146560(29440K)
    10
    堆内存的当前内存使用量:init = 31457280(30720K) used = 12102480(11818K) committed = 30146560(29440K) max = 30146560(29440K)
    11
    堆内存的当前内存使用量:init = 31457280(30720K) used = 13151072(12842K) committed = 30146560(29440K) max = 30146560(29440K)
    12
    堆内存的当前内存使用量:init = 31457280(30720K) used = 14199664(13866K) committed = 30146560(29440K) max = 30146560(29440K)
    13
    [GC [PSYoungGen: 8654K->1248K(8960K)] 13866K->13628K(29440K), 0.0014215 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
    堆内存的当前内存使用量:init = 31457280(30720K) used = 15061144(14708K) committed = 30146560(29440K) max = 30146560(29440K)
    14
    堆内存的当前内存使用量:init = 31457280(30720K) used = 16109736(15732K) committed = 30146560(29440K) max = 30146560(29440K)
    15
    堆内存的当前内存使用量:init = 31457280(30720K) used = 17158328(16756K) committed = 30146560(29440K) max = 30146560(29440K)
    16
    堆内存的当前内存使用量:init = 31457280(30720K) used = 18206920(17780K) committed = 30146560(29440K) max = 30146560(29440K)
    17
    堆内存的当前内存使用量:init = 31457280(30720K) used = 19255512(18804K) committed = 30146560(29440K) max = 30146560(29440K)
    18
    堆内存的当前内存使用量:init = 31457280(30720K) used = 20304104(19828K) committed = 30146560(29440K) max = 30146560(29440K)
    19
    堆内存的当前内存使用量:init = 31457280(30720K) used = 21352696(20852K) committed = 30146560(29440K) max = 30146560(29440K)
    20
    [GC [PSYoungGen: 8472K->1200K(8960K)] 20852K->20748K(29440K), 0.0015864 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
    [Full GC [PSYoungGen: 1200K->1040K(8960K)] [PSOldGen: 19548K->19663K(20480K)] 20748K->20703K(29440K) [PSPermGen: 3887K->3887K(20480K)], 0.0250062 secs] [Times: user=0.00 sys=0.00, real=0.02 secs] 
    堆内存的当前内存使用量:init = 31457280(30720K) used = 22443752(21917K) committed = 30146560(29440K) max = 30146560(29440K)
    21
    堆内存的当前内存使用量:init = 31457280(30720K) used = 23492344(22941K) committed = 30146560(29440K) max = 30146560(29440K)
    22
    堆内存的当前内存使用量:init = 31457280(30720K) used = 24540936(23965K) committed = 30146560(29440K) max = 30146560(29440K)
    23
    堆内存的当前内存使用量:init = 31457280(30720K) used = 25589528(24989K) committed = 30146560(29440K) max = 30146560(29440K)
    24
    堆内存的当前内存使用量:init = 31457280(30720K) used = 26638120(26013K) committed = 30146560(29440K) max = 30146560(29440K)
    25
    堆内存的当前内存使用量:init = 31457280(30720K) used = 27686712(27037K) committed = 30146560(29440K) max = 30146560(29440K)
    26
    [Full GC [PSYoungGen: 7374K->7374K(8960K)] [PSOldGen: 19663K->19663K(20480K)] 27037K->27037K(29440K) [PSPermGen: 3889K->3889K(20480K)], 0.0034263 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
    [Full GC [PSYoungGen: 7374K->7184K(8960K)] [PSOldGen: 19663K->19634K(20480K)] 27037K->26818K(29440K) [PSPermGen: 3889K->3881K(20480K)], 0.0091912 secs] [Times: user=0.02 sys=0.00, real=0.01 secs] 
    java.lang.OutOfMemoryError: Java heap space
    Dumping heap to C:\Users\Administrator\Desktop\error_logs ...
    Unable to create C:\Users\Administrator\Desktop\error_logs: No such file or directory
    Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
        at TestJvm.<init>(TestJvm.java from InputFileObject:7)
        at TestJvm.main(TestJvm.java from InputFileObject:16)
    Heap
     PSYoungGen      total 8960K, used 7285K [0x00000000ff600000, 0x0000000100000000, 0x0000000100000000)
      eden space 7680K, 94% used [0x00000000ff600000,0x00000000ffd1d640,0x00000000ffd80000)
      from space 1280K, 0% used [0x00000000ffd80000,0x00000000ffd80000,0x00000000ffec0000)
      to   space 1280K, 0% used [0x00000000ffec0000,0x00000000ffec0000,0x0000000100000000)
     PSOldGen        total 20480K, used 19634K [0x00000000fe200000, 0x00000000ff600000, 0x00000000ff600000)
      object space 20480K, 95% used [0x00000000fe200000,0x00000000ff52c820,0x00000000ff600000)
     PSPermGen       total 20480K, used 3890K [0x00000000fce00000, 0x00000000fe200000, 0x00000000fe200000)
      object space 20480K, 18% used [0x00000000fce00000,0x00000000fd1cca28,0x00000000fe200000)

     

    展开全文
  • JVM GC时堆内存中新生代的复制算法

    千次阅读 2017-12-05 16:14:12
    JVM GC过程中新生代的复制算法JVM虚拟机中对内存进行回收主要就是对堆内存的回收,heap区把堆内存分为新生代和旧生代 - 新生代:主要存放新new出来的对象 - 旧生代:在新生代中经过多次回收都没有被回收掉的对象就...

    JVM GC过程中新生代的复制算法

    JVM虚拟机中对内存进行回收主要就是对堆内存的回收,heap区把堆内存分为新生代和旧生代
    - 新生代:主要存放新new出来的对象
    - 旧生代:在新生代中经过多次回收都没有被回收掉的对象就会放入旧生代,默认16次

    1.为什么要划分出新生代和旧生代

    在JVM 进行内存回收的时候jvm每次都对所有内存空间做查找回收,显然是很低效的事情,所以JVM将堆内存划分出一块新生代,将新创建的对象都放在里面,内存满了就在新生代中做GC。这样可以提高回收效率。

    2.新生代内的区域划分

    新生代作为内存回收的重点区域,是被垃圾回收器光顾频率最高的地方,没有两把刷子怎么能做好工作,新生代又分为Eden区和Survivor区,只从名字我们也能看出个123。
    - Eden:伊甸园,亚当和夏娃啪啪造人的地方,很明显,新对象肯定放在这里
    - Survivor:幸存者区,那些没有被回收掉的对象肯定是放在这里了

    当然事情肯定没这么简单…

    1. Survivor做不做回收,如果不做回收,那它里面的对象岂不是经过一次GC就高枕无忧了,所以回收肯定是要做的
    2. 如果Survivor做了回收,有的对象被回收掉了,新的对象被加入进来,每个对象所用的空间又不是一样的,这样就会产生内存碎片

    …..艹,你想怎么样

    所以Survivor区又划分为两个大小一样的部分,FromSpace和ToSpace。

    3.新生代内存回收的复制算法

    好了,做了那么多铺垫,本文的重点来了!!!
    从前面我们知道新生代被分为Enden和Survivor区,而Survivor区又分为两个大小完全一样的部分。
    复制回收算法很简单就是两步
    1. 把Enden区和Survivor中有内容的那一部分不被回收的对象,复制存入Survivor中没有内容的那一部分
    2. 把Enden区和Survivor中的FromSpace清空。一次回收就完成了,此时一开始Survivor中有内容的那一部分变为没有内容的那一部分,没有内容的那一部分变成有内容的那一部分(这一句要好好理解,很多同学因为这一点没想通,一直不太理解。不要问我为什么(┬_┬))

    好了,这样就搞定了,还不会存在内存碎片。当下一次GC时重复执行第一步和第二步就可以了。


    展开全文
  • JDK1.8中JVM堆中新生代三部分比例不是8:1:1的问题来源于: 1.JDK1.8中的默认GC UseParallelGC 会自动开启 UseAdaptiveSizePolicy 「自适应大小策略」,会导致自动调整新生代各区域大小; 2.但使用 关闭命令:-XX:-...

    0.结论

    JDK1.8中JVM堆中新生代三部分比例不是8:1:1的问题来源于:
    1.JDK1.8中的默认GC UseParallelGC 会自动开启 UseAdaptiveSizePolicy 「自适应大小策略」,会导致自动调整新生代各区域大小
    2.但使用 关闭命令:-XX:-UseAdaptiveSizePolicy 无法关闭该策略,原因未知;
    3. 如需要看到8:1:1的默认比例方法如下:

    • -XX:SurvivorRatio=8
    • 使用CMS等默认关闭 AdaptiveSizePolicy 的GC算法

    1.起因

    最近研究虚拟机,在学习到运行时数据区中的java堆有这样的疑问
    -XX:SurvivorRatio在缺省的情况下表示新生代Eden区域和Survivor区域(From幸存区或To幸存区)的比例默认为8,即Eden区域与From区域与to区域的比例为8:1:1
    但是实际测试并不是这样的

    2.实际测试

    本人环境:

    java version “1.8.0_251”
    Java™ SE Runtime Environment (build 1.8.0_251-b08)
    Java HotSpot™ 64-Bit Server VM (build 25.251-b08, mixed mode)

    2.1参数为 -Xms300m -Xmx300m 时,比例6:1:1

    在这里插入图片描述
    此时居然6:1:1!查询资料可知与「自适应大小策略」有关,在jdk1.8中,默认的GC为UseParallelGC,该垃圾回收器默认开启了AdaptiveSizePolicy(相关源码 arguments.cpp中的set_parallel_gc_flags 方法

    如果开启了这个参数,则每次 GC 后会重新计算 Eden、From 和 To 区的大小。计算依据是 GC 过程中统计的 GC 时间、吞吐量、内存占用量。

    知道了原因,如何解决呢?

    2.2 参数为-Xms300m -Xmx300m -XX:-UseAdaptiveSizePolicy 时,比例仍为6:1:1

    在这里插入图片描述
    在这里插入图片描述

    开启:-XX:+UseAdaptiveSizePolicy
    关闭:-XX:-UseAdaptiveSizePolicy

    虽然我使用 jinfo 命令确认了显式地关闭了 UseAdaptiveSizePolicy ,但比例仍然对不上,这让我困惑

    2.3参数为-Xms300m -Xmx300m -XX:SurvivorRatio=8 时,比例8:1:1

    在这里插入图片描述
    使用 -XX:SurvivorRatio 指令后发现eden和survivor变成了熟悉缺省比例。
    另外查询资料发现,来源:IBM Knowledge Center

    避免故障
    -XX:SurvivorRatio= option 与 Java 虚拟机参数 -XX:+UseAdaptiveSizePolicy 不相容。 因此请根据您的情况使用其中某一个值。

    -XX:SurvivorRatio = option-XX:+UseAdaptiveSizePolicy 最好别一起用,
    另外在使用 -XX:SurvivorRatio,最好关闭「自适应大小策略」 -XX:-UseAdaptiveSizePolicy。(查询资料中发现有些人需要将前两个命令都设置才能看到8:1:1的效果,可能是JDK版本问题)

    3.其它收获

    1. 为什么 CMS GC 默认关闭 UseAdaptiveSizePolicy ?
      在arguments.cpp 类中的 set_cms_and_parnew_gc_flags 方法,其调用了 disable_adaptive_size_policy 方法将 UseAdaptiveSizePolicy 设置成 false。

    在这里插入图片描述
    具体静态方法的代码
    在这里插入图片描述

    4.参考文章

    1. JVM GC 之「AdaptiveSizePolicy」实战
    2. openjdk-jdk8u的arguments.cpp 源码「Github」
    3. Sun HotSpot JVM tuning parameters (Solaris and HP-UX)「IBM Knowledge Center」
    展开全文
  • JVM中新生代和老年代

    2019-09-19 16:16:50
    Java,堆被分为:新生代(Young)、老年代(Old)。 新生代又被分为:Eden、From Survivor、To Survivor。 新生代:老年代=1:2 ,即新生代(1/3堆空间)、老年代(2/3堆空间) 新生代中:Eden:from:to=8:1:1. ...

    Java中,堆被分为:新生代(Young)、老年代(Old)。

    新生代又被分为:Eden、From Survivor、To Survivor。

    新生代:老年代=1:2 ,即新生代(1/3堆空间)、老年代(2/3堆空间)

    新生代中:Eden:from:to=8:1:1.

     

     

    -Xmn来控制新生代,也可以用-XX:SurvivorRatio来控制Eden和Survivor的比例旧生代
     -XX:NewRatio=4:设置年轻代(包括Eden和两个Survivor区)与年老代的比值(除去持久代).设置为4,则年轻代与年老代所占比值为1:4,年轻代占整个堆栈的1/5

     

    展开全文
  • 根据松江地区、鸟取县东部的新生代火山岩类的比较结果,讨论日本中国地区新生代火山岩的岩石成因,认为:火山岩浆在上升过程,在岩浆演化晚期阶段,与围岩发生了同化混染作用,使得最终凝固结晶形成的火山岩化学成分发生...
  • 应用磷灰石裂变径迹定年技术研究鄂尔多斯盆地南缘渭北隆起抬升期次及演化过程。...始新世—渐新世以来的断块敲倾作用阶段,与秦岭造山带始新世以来的快速隆升,以及渭河盆地新生代的快速断陷作用有关。
  • 所有通过new创建的对象的内存都在堆分配,其大小可以通过-Xmx和-Xms来控制。堆被划分为新生代和旧生代,新生代又被进一步划分为Eden和Survivor区,最后Survivor由FromSpace和ToSpace组成。 一般情况将新生代分为...
  • JVMjava的Heap(堆)是JVM所管理的最大的一块内存空间,主要用于存放各种类的实例对象。由于Java堆是垃圾收集器管理的主要区域,因此也被称为“GC堆”GC分为两种:Minor GC,Full GC(或者称为Major GC)在Java,堆被...
  • 成煤盆地的构造演化主要经历了两期构造沉降和两期构造反转,两期的构造沉降形成了东部地区的成煤盆地,随后发生的两期构造反转对煤系的保存有一定的破坏作用,两方面构造作用的叠加,造就了煤系赋存在一系列孤立的小型...
  • JVM中新生代,老年代

    2019-09-23 12:58:43
    java的Heap(堆)是JVM所管理的最大的一块内存空间,主要用于存放各种类的实例对象。由于Java堆是垃圾收集器管理的主要区域,因此也被称为“GC堆”GC分为两种:Minor GC,Full GC(或者称为Major GC) 在Java...
  • jvm中新生代和老年代的理解

    千次阅读 2017-12-11 14:30:19
    堆用于存储对象实例及数组值,可以认为Java所有通过new...1. 新生代(New Generation)大多数情况下Java程序新建的对象都从新生代分配内存,新生代由Eden Space和两块相同大小的Survivor Space(通常又称为S0和S
  • java中新生代和老年代

    千次阅读 2018-06-25 21:26:49
    Old:主要存放应用程序生命周期长的内存对象。 Permanent:是指内存的永久保存区域,主要存放Class和Meta的信息,Class在被 Load的时候被放入PermGen space区域. 它和和存放Instance的Heap区域不同,GC(Garbage ...
  • 新生代中,每次垃圾收集时都发现大批对象死去,只有少量对象存活,便采用了复制算法,只需要付出少量存活对象的复制成本就可以完成收集。而老年代因为对象存活率高、没有额外空间对它进行分配担保,就必须采用...
  • 新生代Eden与两个Survivor区的理解 jvm的年轻代 1.为什么会有年轻代 为什么需要吧堆分代?不分代不能完成他所做的事情么?其实不分代完成可以,分代的唯一理由就是优化GC性能。如果没有分店,那所有的对象都在一块,...
  • -Xms、-Xmx都是1024M,通过...没有配置-Xmn(新生代区大小)。通过网上的文章看新生代区:默认老年区是1:4,但是我这个是83.19:940.81都小于1:10了。求大神解答什么回事,新生代区用的是parNew,老年代区用的是CMS。
  • java 堆中新生代老年代

    千次阅读 2015-09-17 20:00:09
    现在应该能理解为什么新生代大小非常重要了(译者,有另外一种说法:新生代大小并不重要,影响GC的因素主要是幸存对象的数量),如果新生代过小,会导致新生对象很快就晋升到老年代,在老年代对象很难被回收。...
  • 新生代的GC过程叫做MinorGC,采用复制算法,流程如下: (1)把在Eden区与ServivorFrom区存活的对象复制到ServivorTo区。如果某对象的年龄达到老年代的标准(对象晋升老年代的标准由XX:MaxTenuringThreshold设置...
  • 1.存储在JVM的Java对象可以被划分为两类:一类生命周期很短,这类对象的创建和消亡很快;一类生命周期很长,极端情况下,还能够与JVM的生命周期保持一致。 2.JVM堆区进一步细分为新生代和老年代。 3.年轻代又可以...
  • 代码清单3-5. /** * VM参数:-verbose:gc -Xms20M -Xmx20M -Xmn10M -XX:+PrintGCDetails -XX:SurvivorRatio=8 * */ public class MinorGCTest { ... private static final int _1MB = 1024*1024;...
  • 由于现在收集器都是采用分代收集算法,堆被划分为新生代和老年代。新生代主要存储新创建的对象和尚未进入老年代的对象。老年代存储经过多次新生代GC(Minor GC)任然存活的对象。  具体定义:所谓的新生代和老年代...
  • 堆内存是垃圾收集器主要光顾的区域,一般来讲根据使用的垃圾收集器的不同,堆还会划分为一些区域,比如新生代和老年代。新生代还可以再划分为Eden,Survivor等区域。另外为了性能和安全性的角度,在堆还会为线程...
  • 一.概述 java的最大好处是自动垃圾回收,这样就无需我们...JVM堆分为新生代,旧生代和年老代,新生代可用的gc方式有:串行gc(Serial Copying),并行回收gc(Parellel Scavenge),并行gc(ParNew),旧生代和年老代
  • 新生代苏北盆地的沉积特征与地形巨变,张振克,田海涛,苏北断陷盆地新生代接受了厚达数千米的巨厚的沉积体系,沉积记录了新生代以来复杂的地质构造变动影响和沉积环境变化过程

空空如也

空空如也

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

中新生代