深入JVM系列（二）之GC机制、收集器与GC调优

一、回顾JVM内存分配

需要了解更多内存模式与内存分配的，请看 深入JVM系列（一）之内存模型与内存分配

1.1、内存分配：

1、对象优先在EDEN分配
2、大对象直接进入老年代 
3、长期存活的对象将进入老年代 
4、适龄对象也可能进入老年代：动态对象年龄判断

动态对象年龄判断：

虚拟机并不总是要求对象的年龄必须达到MaxTenuringThreshold才能晋升到老年代，当Survivor空间的相同年龄的所有对象大小总和大于Survivor空间的一半，年龄大于或等于该年龄的对象就可以直接进入老年代，无需等到MaxTenuringThreshold中指定的年龄

1.2、总结一下：

1、对象优先在Eden分配，这里大部分对象具有朝生夕灭的特征，Minor GC主要清理该处
2、大对象（占内存大）、老对象（使用频繁）

3、Survivor无法容纳的对象，将进入老年代，Full GC的主要清理该处

二、JVM的GC机制

JVM有2个GC线程

第一个线程负责回收Heap的Young区
第二个线程在Heap不足时，遍历Heap，将Young 区升级为Older区

Older区的大小等于-Xmx减去-Xmn，不能将-Xms的值设的过大，因为第二个线程被迫运行会降低JVM的性能。

2.1、堆内存GC

       JVM(采用分代回收的策略)，用较高的频率对年轻的对象(young generation)进行YGC，而对老对象(tenured generation)较少(tenured generation 满了后才进行)进行Full GC。这样就不需要每次GC都将内存中所有对象都检查一遍。

2.2、非堆内存不GC

      GC不会在主程序运行期对PermGen Space进行清理，所以如果你的应用中有很多CLASS(特别是动态生成类，当然permgen space存放的内容不仅限于类)的话,就很可能出现PermGen Space错误。

2.3、内存申请、对象衰老过程

2.3.1、内存申请过程

1. JVM会试图为相关Java对象在Eden中初始化一块内存区域；
2. 当Eden空间足够时，内存申请结束。否则到下一步；
3. JVM试图释放在Eden中所有不活跃的对象（minor collection），释放后若Eden空间仍然不足以放入新对象，则试图将部分Eden中活跃对象放入Survivor区；
4. Survivor区被用来作为Eden及old的中间交换区域，当OLD区空间足够时，Survivor区的对象会被移到Old区，否则会被保留在Survivor区；
5. 当old区空间不够时，JVM会在old区进行major collection；
6. 完全垃圾收集后，若Survivor及old区仍然无法存放从Eden复制过来的部分对象，导致JVM无法在Eden区为新对象创建内存区域，则出现"Out of memory错误"；

2.3.2、对象衰老过程

1. 新创建的对象的内存都分配自eden。Minor collection的过程就是将eden和在用survivor space中的活对象copy到空闲survivor space中。对象在young generation里经历了一定次数(可以通过参数配置)的minor collection后，就会被移到old generation中，称为tenuring。

GC触发条件

GC类型	触发条件	触发时发生了什么	注意	查看方式
YGC	eden空间不足	清空Eden+from survivor中所有no ref的对象占用的内存 将eden+from sur中所有存活的对象copy到to sur中 一些对象将晋升到old中:     to sur放不下的     存活次数超过turning threshold中的 重新计算tenuring threshold(serial parallel GC会触发此项) 重新调整Eden 和from的大小(parallel GC会触发此项)	全过程暂停应用 是否为多线程处理由具体的GC决定	jstat –gcutil  gc log
FGC	old空间不足 perm空间不足 显示调用System.GC, RMI等的定时触发 YGC时的悲观策略 dump live的内存信息时(jmap –dump:live)	清空heap中no ref的对象 permgen中已经被卸载的classloader中加载的class信息 如配置了CollectGenOFirst,则先触发YGC(针对serial GC) 如配置了ScavengeBeforeFullGC,则先触发YGC(针对serial GC)	全过程暂停应用 是否为多线程处理由具体的GC决定 是否压缩需要看配置的具体GC	jstat –gcutil  gc log

permanent generation空间不足会引发Full GC,仍然不够会引发PermGen Space错误。

三、GC监视、收集器与GC调优

3.1、监视JVM GC

首先说一下如何监视JVM GC，可以用JDK中的jstat工具，也可以在java程序启动的opt里加上如下几个参数（注:这两个参数只针对SUN的HotSpotVM）：

-XX:-PrintGCPrintmessagesatgarbagecollection.Manageable.
-XX:-PrintGCDetailsPrintmoredetailsatgarbagecollection.Manageable.(Introducedin1.4.0.)
-XX:-PrintGCTimeStampsPrinttimestampsatgarbagecollection.Manageable(Introducedin1.4.0.)

-XX:-PrintGCPrintmessagesatgarbagecollection.Manageable.  
-XX:-PrintGCDetailsPrintmoredetailsatgarbagecollection.Manageable.(Introducedin1.4.0.)  
-XX:-PrintGCTimeStampsPrinttimestampsatgarbagecollection.Manageable(Introducedin1.4.0.) 

当把-XX:-PrintGCDetails加入到javaopt里以后可以看见如下输出：

[GC[DefNew:34538K->2311K(36352K),0.0232439secs]45898K->15874K(520320K),0.0233874secs]
[FullGC[Tenured:13563K->15402K(483968K),0.2368177secs]21163K->15402K(520320K),[Perm:28671K->28635K(28672K)],0.2371537secs]

他们分别显示了JVM GC的过程，清理出了多少空间。第一行GC使用的是‘普通GC’(MinorCollections)，第二行使用的是‘全GC’(MajorCollections)。他们的区别很大，在第一行最后我们可以看见他的时间是0.0233874秒，而第二行的FullGC的时间是0.2371537秒。第二行的时间是第一行的接近10倍，也就是我们这次调优的重点，减少FullGC的次数，以为FullGC会暂停程序比较长的时间，如果FullGC的次数比较多。程序就会经常性的假死。

注：

GC信息的格式

[GC [: -> , secs] -> , secs]
GC为minor收集过程中使用的垃圾收集器起的内部名称.
young generation 在进行垃圾收集前被对象使用的存储空间.
young generation 在进行垃圾收集后被对象使用的存储空间
minor收集使应用暂停的时间长短(秒) 
整个堆(Heap Size)在进行垃圾收集前被对象使用的存储空间
整个堆(Heap Size)在进行垃圾收集后被对象使用的存储空间
整个垃圾收集使应用暂停的时间长短(秒),包括major收集使应用暂停的时间(如果发生了major收集).

GC信息的选项

-XX:+PrintGCDetails 显示GC的详细信息
-XX:+PrintGCApplicationConcurrentTime 打印应用执行的时间
-XX:+PrintGCApplicationStoppedTime 打印应用被暂停的时间

3.2、collector收集器的种类   

   

GC在 HotSpot VM 5.0里有四种：

incremental (sometimes called train) low pause collector已被废弃,不在介绍.

类别	serial collector	parallel collector ( throughput collector )	concurrent collector (concurrent low pause collector)
介绍	单线程收集器 使用单线程去完成所有的gc工作，没有线程间的通信，这种方式会相对高效	并行收集器 使用多线程的方式，利用多CUP来提高GC的效率 主要以到达一定的吞吐量为目标	并发收集器 使用多线程的方式,利用多CUP来提高GC的效率 并发完成大部分工作，使得gc pause短
试用场景	单处理器机器且没有pause time的要求	适用于科学技术和后台处理 有中规模/大规模数据集大小的应用且运行在多处理器上，关注吞吐量(throughput)	适合中规模/大规模数据集大小的应用，应用服务器,电信领域 关注response time，而不是throughput
使用	Client模式下默认 可使用 可用-XX:+UseSerialGC强制使用 优点:对server应用没什么优点 缺点:慢,不能充分发挥硬件资源	Server模式下默认 --YGC:PS FGC:Parallel MSC 可用-XX:+UseParallelGC或-XX:+UseParallelOldGC强制指定 --ParallelGC代表FGC为Parallel MSC --ParallelOldGC代表FGC为Parallel Compacting 优点:高效 缺点:当heap变大后,造成的暂停时间会变得比较长	可用-XX:+UseConcMarkSweepGC强制指定 优点: 对old进行回收时,对应用造成的暂停时间非常端,适合对latency要求比较高的应用 缺点: 1.内存碎片和浮动垃圾 2.old去的内存分配效率低 3.回收的整个耗时比较长 4.和应用争抢CPU
内存回收触发	YGC eden空间不足 FGC old空间不足 perm空间不足 显示调用System.gc() ,包括RMI等的定时触发 YGC时的悲观策略 dump live的内存信息时(jmap –dump:live)	YGC eden空间不足 FGC old空间不足 perm空间不足 显示调用System.gc() ,包括RMI等的定时触发 YGC时的悲观策略--YGC前&YGC后 dump live的内存信息时(jmap –dump:live)	YGC eden空间不足 CMS GC 1.old Gen的使用率大的一定的比率 默认为92% 2.配置了CMSClassUnloadingEnabled,且Perm Gen的使用达到一定的比率 默认为92% 3.Hotspot自己根据估计决定是否要触法 4.在配置了ExplictGCInvokesConcurrent的情况下显示调用了System.gc. Full GC(Serial MSC) promotion failed 或 concurrent Mode Failure时;
内存回收触发时发生了什么	YGC eden空间不足 FGC old空间不足 perm空间不足 显示调用System.gc() ,包括RMI等的定时触发 YGC时的悲观策略 dump live的内存信息时(jmap –dump:live)	YGC 同serial动作基本相同,不同点: 1.多线程处理 2.YGC的最后不仅重新计算Tenuring Threshold,还会重新调整Eden和From的大小 FGC 1.如配置了ScavengeBeforeFullGC(默认),则先触发YGC(??) 2.MSC:清空heap中的no ref对象,permgen中已经被卸载的classloader中加载的class信息,并进行压缩 3.Compacting:清空heap中部分no ref的对象,permgen中已经被卸载的classloader中加载的class信息,并进行部分压缩 多线程做以上动作.	YGC 同serial动作基本相同,不同点: 1.多线程处理 CMSGC: 1.old gen到达比率时只清除old gen中no ref的对象所占用的空间 2.perm gen到达比率时只清除已被清除的classloader加载的class信息 FGC 同serial
细节参数	可用-XX:+UseSerialGC强制使用 -XX:SurvivorRatio=x,控制eden/s0/s1的大小 -XX:MaxTenuringThreshold,用于控制对象在新生代存活的最大次数 -XX:PretenureSizeThreshold=x,控制超过多大的字节的对象就在old分配.	-XX:SurvivorRatio=x,控制eden/s0/s1的大小 -XX:MaxTenuringThreshold,用于控制对象在新生代存活的最大次数 -XX:UseAdaptiveSizePolicy 去掉YGC后动态调整eden from已经tenuringthreshold的动作 -XX:ParallelGCThreads 设置并行的线程数	-XX:CMSInitiatingOccupancyFraction 设置old gen使用到达多少比率时触发 -XX:CMSInitiatingPermOccupancyFraction,设置Perm Gen使用到达多少比率时触发 -XX:+UseCMSInitiatingOccupancyOnly禁止hostspot自行触发CMS GC

注：

• throughput collector与concurrent low pause collector的区别是throughput collector只在young area使用使用多线程，而concurrent low pause collector则在tenured generation也使用多线程。
• 根据官方文档，他们俩个需要在多CPU的情况下，才能发挥作用。在一个CPU的情况下，会不如默认的serial collector，因为线程管理需要耗费CPU资源。而在两个CPU的情况下，也提高不大。只是在更多CPU的情况下，才会有所提高。当然 concurrent low pause collector有一种模式可以在CPU较少的机器上，提供尽可能少的停顿的模式，见CMS GC Incremental mode。
• 当要使用throughput collector时，在java opt里加上-XX:+UseParallelGC，启动throughput collector收集。也可加上-XX:ParallelGCThreads=来改变线程数。还有两个参数 -XX:MaxGCPauseMillis=和 -XX:GCTimeRatio=，MaxGCPauseMillis=用来控制最大暂停时间，而-XX: GCTimeRatio可以提高GC说占CPU的比，以最大话的减小heap。

附注SUN的官方说明： 

1. The throughput collector: this collector uses a parallel version of the young generation collector. It is used if the -XX:+UseParallelGC option is passed on the command line. The tenured generation collector is the same as the serial collector.

2. The concurrent low pause collector: this collector is used if the -Xincgc™ or -XX:+UseConcMarkSweepGC is passed on the command line. The concurrent collector is used to collect the tenured generation and does most of the collection concurrently with the execution of the application. The application is paused for short periods during the collection. A parallel version of the young generation copying collector is used with the concurrent collector. The concurrent low pause collector is used if the option -XX:+UseConcMarkSweepGC is passed on the command line.

3. The incremental (sometimes called train) low pause collector: this collector is used only if -XX:+UseTrainGC is passed on the command line. This collector has not changed since the J2SE Platform version 1.4.2 and is currently not under active development. It will not be supported in future releases. Please see the 1.4.2 GC Tuning Document for information on this collector.

1. The throughput collector: this collector uses a parallel version of the young generation collector. It is used if the -XX:+UseParallelGC option is passed on the command line. The tenured generation collector is the same as the serial collector.

2. The concurrent low pause collector: this collector is used if the -Xincgc™ or -XX:+UseConcMarkSweepGC is passed on the command line. The concurrent collector is used to collect the tenured generation and does most of the collection concurrently with the execution of the application. The application is paused for short periods during the collection. A parallel version of the young generation copying collector is used with the concurrent collector. The concurrent low pause collector is used if the option -XX:+UseConcMarkSweepGC is passed on the command line.

3. The incremental (sometimes called train) low pause collector: this collector is used only if -XX:+UseTrainGC is passed on the command line. This collector has not changed since the J2SE Platform version 1.4.2 and is currently not under active development. It will not be supported in future releases. Please see the 1.4.2 GC Tuning Document for information on this collector.

CMS GC Incremental mode

       当要使用 concurrent low pause collector时，在java的opt里加上 -XX:+UseConcMarkSweepGC。concurrent low pause collector还有一种为CPU少的机器准备的模式，叫Incremental mode。这种模式使用一个CPU来在程序运行的过程中GC，只用很少的时间暂停程序，检查对象存活。

       在Incremental mode里，每个收集过程中，会暂停两次，第二次略长。第一次用来，简单从root查询存活对象。第二次用来，详细检查存活对象。整个过程如下：

* stop all application threads; do the initial mark; resume all application threads（第一次暂停，初始话标记）
* do the concurrent mark (uses one procesor for the concurrent work)（运行是标记）
* do the concurrent pre-clean (uses one processor for the concurrent work)（准备清理）
* stop all application threads; do the remark; resume all application threads（第二次暂停，标记，检查）
* do the concurrent sweep (uses one processor for the concurrent work)(运行过程中清理)
* do the concurrent reset (uses one processor for the concurrent work)(复原)

* stop all application threads; do the initial mark; resume all application threads（第一次暂停，初始话标记）
* do the concurrent mark (uses one procesor for the concurrent work)（运行是标记）
* do the concurrent pre-clean (uses one processor for the concurrent work)（准备清理）
* stop all application threads; do the remark; resume all application threads（第二次暂停，标记，检查）
* do the concurrent sweep (uses one processor for the concurrent work)(运行过程中清理)
* do the concurrent reset (uses one processor for the concurrent work)(复原)

       当要使用Incremental mode时，需要使用以下几个变量：

-XX:+CMSIncrementalMode default: disabled 启动i-CMS模式（must with -XX:+UseConcMarkSweepGC）
-XX:+CMSIncrementalPacing default: disabled 提供自动校正功能
-XX:CMSIncrementalDutyCycle= default: 50 启动CMS的上线
-XX:CMSIncrementalDutyCycleMin= default: 10 启动CMS的下线
-XX:CMSIncrementalSafetyFactor= default: 10 用来计算循环次数
-XX:CMSIncrementalOffset= default: 0 最小循环次数（This is the percentage (0-100) by which the incremental mode duty cycle is shifted to the right within the period between minor collections.）
-XX:CMSExpAvgFactor= default: 25 提供一个指导收集数

-XX:+CMSIncrementalMode default: disabled 启动i-CMS模式（must with -XX:+UseConcMarkSweepGC）
-XX:+CMSIncrementalPacing default: disabled 提供自动校正功能
-XX:CMSIncrementalDutyCycle= default: 50 启动CMS的上线
-XX:CMSIncrementalDutyCycleMin= default: 10 启动CMS的下线
-XX:CMSIncrementalSafetyFactor= default: 10 用来计算循环次数
-XX:CMSIncrementalOffset= default: 0 最小循环次数（This is the percentage (0-100) by which the incremental mode duty cycle is shifted to the right within the period between minor collections.）
-XX:CMSExpAvgFactor= default: 25 提供一个指导收集数

     SUN推荐的使用参数是：

-XX:+UseConcMarkSweepGC \
-XX:+CMSIncrementalMode \
-XX:+CMSIncrementalPacing \
-XX:CMSIncrementalDutyCycleMin=0 \
-XX:CMSIncrementalDutyCycle=10 \
-XX:+PrintGC Details \
-XX:+PrintGCTimeStamps \
-XX:-TraceClassUnloading

-XX:+UseConcMarkSweepGC \
-XX:+CMSIncrementalMode \
-XX:+CMSIncrementalPacing \
-XX:CMSIncrementalDutyCycleMin=0 \
-XX:CMSIncrementalDutyCycle=10 \
-XX:+PrintGC Details \
-XX:+PrintGCTimeStamps \
-XX:-TraceClassUnloading

注：如果使用throughput collector和concurrent low pause collector，这两种垃圾收集器，需要适当的挺高内存大小，以为多线程做准备。

3.3、如何选择collector

• app运行在单处理器机器上且没有pause time的要求，让vm选择UseSerialGC.
• 重点考虑peak application performance(高性能)，没有pause time太严格要求，让vm选择或者UseParallelGC+UseParallelOldGC(optionally).
• 重点考虑response time,pause time要小，UseConcMarkSweepGC.

Garbage Collctor – Future

Garbage First(G1)
jdk1.6 update 14 or jdk7
few flags need to set
-XX:MaxGCPauseMillis=100
-XX:GCPauseIntervalMillis=6000

Garbage First(G1)
jdk1.6 update 14 or jdk7
few flags need to set
-XX:MaxGCPauseMillis=100
-XX:GCPauseIntervalMillis=6000

     还没尝试过使用…

Summary

import java.util.ArrayList;
import java.util.List;
public class SummaryCase {
    public static void main(String[] args) throws InterruptedException {
        List caches = new ArrayList();   
             for (int i = 0; i < 7; i++) {   
                 caches.add(new byte[1024 * 1024 * 3]);   
                 Thread.sleep(1000);   
             }   
             caches.clear();   
             for (int i = 0; i < 2; i++) {   
                 caches.add(new byte[1024 * 1024 * 3]);   
                 Thread.sleep(1000);   
             }   
         }   
     }   
     
    
   import java.util.ArrayList;
import java.util.List;
public class SummaryCase {
    public static void main(String[] args) throws InterruptedException {
        List caches = new ArrayList();
        for (int i = 0; i < 7; i++) {
            caches.add(new byte[1024 * 1024 * 3]);
            Thread.sleep(1000);
        }
        caches.clear();
        for (int i = 0; i < 2; i++) {
            caches.add(new byte[1024 * 1024 * 3]);
            Thread.sleep(1000);
        }
    }
} 
    
    } 
    
    
    
   
   
   用以下两种参数执行,会执行几次YGC几次FGC? 
   
   
    
   
   
   -Xms30M -Xmx30M -Xmn10M  -Xloggc:gc.log -XX:+PrintTenuringDistribution -XX:+UseParallelGC 
   
   
    
   
   
    
   2.062: [GC
Desired survivor size 1310720 bytes, new threshold 7 (max 15)
 6467K->6312K(29440K), 0.0038214 secs]
4.066: [GC
Desired survivor size 1310720 bytes, new threshold 7 (max 15)
 12536K->12440K(29440K), 0.0036804 secs]
6.070: [GC
Desired survivor size 1310720 bytes, new threshold 7 (max 15)
 18637K->18584K(29440K), 0.0040175 secs]
6.074: [Full GC 18584K->18570K(29440K), 0.0031329 secs]
8.078: [Full GC 24749K->3210K(29440K), 0.0045590 secs] 
   2.062: [GC
Desired survivor size 1310720 bytes, new threshold 7 (max 15)
 6467K->6312K(29440K), 0.0038214 secs]
4.066: [GC
Desired survivor size 1310720 bytes, new threshold 7 (max 15)
 12536K->12440K(29440K), 0.0036804 secs]
6.070: [GC
Desired survivor size 1310720 bytes, new threshold 7 (max 15)
 18637K->18584K(29440K), 0.0040175 secs]
6.074: [Full GC 18584K->18570K(29440K), 0.0031329 secs]
8.078: [Full GC 24749K->3210K(29440K), 0.0045590 secs] 
    
   (具体分析见 
   http://rdc.taobao.com/team/jm/archives/440 
   ) 
    
   
   
    
   
   
   -Xms30M -Xmx30M -Xmn10M  -Xloggc:gc.log -XX:+PrintTenuringDistribution -XX:+UseSerialGC 
   
   
    
   2.047: [GC
Desired survivor size 524288 bytes, new threshold 15 (max 15)
- age   1:     142024 bytes,     142024 total
 6472K->6282K(29696K), 0.0048686 secs]
4.053: [GC
Desired survivor size 524288 bytes, new threshold 15 (max 15)
- age   2:     141880 bytes,     141880 total
 12512K->12426K(29696K), 0.0047334 secs]
6.058: [GC
Desired survivor size 524288 bytes, new threshold 15 (max 15)
- age   3:     141880 bytes,     141880 total
 18627K->18570K(29696K), 0.0049135 secs]
8.063: [Full GC 24752K->3210K(29696K), 0.0077895 secs] 
   2.047: [GC
Desired survivor size 524288 bytes, new threshold 15 (max 15)
- age   1:     142024 bytes,     142024 total
 6472K->6282K(29696K), 0.0048686 secs]
4.053: [GC
Desired survivor size 524288 bytes, new threshold 15 (max 15)
- age   2:     141880 bytes,     141880 total
 12512K->12426K(29696K), 0.0047334 secs]
6.058: [GC
Desired survivor size 524288 bytes, new threshold 15 (max 15)
- age   3:     141880 bytes,     141880 total
 18627K->18570K(29696K), 0.0049135 secs]
8.063: [Full GC 24752K->3210K(29696K), 0.0077895 secs]

 
   (具体分析见 
   http://rdc.taobao.com/team/jm/archives/458 
   ) 
   
   
    
   
  四、GC调优的小例子 
   
    
   
   
  例1：Heap size 设置  
   
    JVM 堆的设置是指java程序运行过程中JVM可以调配使用的内存空间的设置.JVM在启动的时候会自动设置Heap size的值，其初始空间(即-Xms)是物理内存的1/64，最大空间(-Xmx)是物理内存的1/4。可以利用JVM提供的-Xmn -Xms -Xmx等选项可进行设置。 
    
   Heap size 的大小是Young Generation 和Tenured Generaion 之和。 当在JAVA_HOME下demo/jfc/SwingSet2/目录下执行下面的命令。 
    
  java -jar -Xmn4m -Xms16m -Xmx16m SwingSet2.jar 
  java -jar -Xmn4m -Xms16m -Xmx16m SwingSet2.jar 
   
   系统输出为： 
   
  Exception in thread "Image Fetcher 0" java.lang.OutOfMemoryError: Java heap space
Exception in thread "Image Fetcher 3" java.lang.OutOfMemoryError: Java heap space
Exception in thread "Image Fetcher 1" java.lang.OutOfMemoryError: Java heap space
Exception in thread "Image Fetcher 2" java.lang.OutOfMemoryError: Java heap space 
  Exception in thread "Image Fetcher 0" java.lang.OutOfMemoryError: Java heap space
Exception in thread "Image Fetcher 3" java.lang.OutOfMemoryError: Java heap space
Exception in thread "Image Fetcher 1" java.lang.OutOfMemoryError: Java heap space
Exception in thread "Image Fetcher 2" java.lang.OutOfMemoryError: Java heap space 
   
   
   
    除了这些异常信息外，还会发现程序的响应速度变慢了。这说明Heap size 设置偏小，GC占用了更多的时间，而应用分配到的执行时间较少。提示：在JVM中如果98％的时间是用于GC且可用的Heap size 不足2％的时候将抛出此异常信息。  
   将上面的命令换成以下命令执行则应用能够正常使用，且未抛出任何异常。 java -jar -Xmn4m -Xms16m -Xmx32m SwingSet2.jar 
   提示：Heap Size 最大不要超过可用物理内存的80％，一般的要将-Xms和-Xmx选项设置为相同，而-Xmn为1/4的-Xmx值。 
    
    
  例2：Young Generation（-Xmn）的设置  
   
    
   
  在本例中看一下Young Generation的设置不同将有什么现象发生。 假设将Young generation 的大小设置为4M ，即执行java -jar -verbose:gc -Xmn4m -Xms32m -Xmx32m -XX:+PrintGCDetails 
   SwingSet2.jar， 
   
    
   屏幕输出如下（节选） 
    
  [GC [DefNew: 3968K->64K(4032K), 0.0923407 secs] 3968K->2025K(32704K), 0.0931870 secs]
[GC [DefNew: 4021K->64K(4032K), 0.0356847 secs] 5983K->2347K(32704K), 0.0365441 secs]
[GC [DefNew: 3995K->39K(4032K), 0.0090603 secs] 6279K->2372K(32704K), 0.0093377 secs] 
  [GC [DefNew: 3968K->64K(4032K), 0.0923407 secs] 3968K->2025K(32704K), 0.0931870 secs]
[GC [DefNew: 4021K->64K(4032K), 0.0356847 secs] 5983K->2347K(32704K), 0.0365441 secs]
[GC [DefNew: 3995K->39K(4032K), 0.0090603 secs] 6279K->2372K(32704K), 0.0093377 secs] 
   
   将程序体制并将Young Generation的大小设置为8M，即执行 
   
    
  java -jar -verbose:gc -Xmn8m -Xms32m -Xmx32m -XX:+PrintGCDetails SwingSet2.jar 
  java -jar -verbose:gc -Xmn8m -Xms32m -Xmx32m -XX:+PrintGCDetails SwingSet2.jar 
   
   
   
   屏幕输出如下（节选） 
  [GC [DefNew: 7808K->192K(8000K), 0.1016784 secs] 7808K->2357K(32576K), 0.1022834 secs]
[GC [DefNew: 8000K->70K(8000K), 0.0149659 secs] 10165K->2413K(32576K), 0.0152557 secs]
[GC [DefNew: 7853K->59K(8000K), 0.0069122 secs] 10196K->2403K(32576K), 0.0071843 secs]
[GC [DefNew: 7867K->171K(8000K), 0.0075745 secs] 10211K->2681K(32576K), 0.0078376 secs]
[GC [DefNew: 7970K->192K(8000K), 0.0201353 secs] 10480K->2923K(32576K), 0.0206867 secs]
[GC [DefNew: 7979K->30K(8000K), 0.1787079 secs] 10735K->4824K(32576K), 0.1790065 secs] 
  [GC [DefNew: 7808K->192K(8000K), 0.1016784 secs] 7808K->2357K(32576K), 0.1022834 secs]
[GC [DefNew: 8000K->70K(8000K), 0.0149659 secs] 10165K->2413K(32576K), 0.0152557 secs]
[GC [DefNew: 7853K->59K(8000K), 0.0069122 secs] 10196K->2403K(32576K), 0.0071843 secs]
[GC [DefNew: 7867K->171K(8000K), 0.0075745 secs] 10211K->2681K(32576K), 0.0078376 secs]
[GC [DefNew: 7970K->192K(8000K), 0.0201353 secs] 10480K->2923K(32576K), 0.0206867 secs]
[GC [DefNew: 7979K->30K(8000K), 0.1787079 secs] 10735K->4824K(32576K), 0.1790065 secs] 
   
   那么根据GC输出的信息（这里取第一行）做一下Minor收集的比较。可以看出两次的Minor收集分别在Young generation中找回3904K（3968K->64K）和7616K(7808K->192K)而对于整个jvm则找回 1943K（3968K->2025）和5451K（7808K->2357K）。第一种情况下Minor收集了大约50％（1943/3904）的对象，而另外的50％的对象则被移到了tenured generation。在第二中情况下Minor收集了大约72％的对象，只有不到30％的对象被移到了Tenured Generation.这个例子说明此应用在的Young generation 设置为4m时显的偏小。 
   
  提示：一般的Young Generation的大小是整个Heap size的1/4。Young generation的minor收集率应一般在70％以上。当然在实际的应用中需要根据具体情况进行调整。 
   
    
    
  例3：Young Generation对应用响应的影响  
   
    
   
  还是使用-Xmn4m 和-Xmn8m进行比较，先执行下面的命令 
   
    
  java -jar -verbose:gc -Xmn4m -Xms32m -Xmx32m -XX:+PrintGCDetails -XX:+PrintGCApplicationConcurrentTime -XX:+PrintGCApplicationStoppedTime SwingSet2.jar 
  java -jar -verbose:gc -Xmn4m -Xms32m -Xmx32m -XX:+PrintGCDetails -XX:+PrintGCApplicationConcurrentTime -XX:+PrintGCApplicationStoppedTime SwingSet2.jar 
   
   屏幕输出如下（节选） 
   
  Application time: 0.5114944 seconds
[GC [DefNew: 3968K->64K(4032K), 0.0823952 secs] 3968K->2023K(32704K), 0.0827626 secs]
Total time for which application threads were stopped: 0.0839428 seconds
Application time: 0.9871271 seconds
[GC [DefNew: 4020K->64K(4032K), 0.0412448 secs] 5979K->2374K(32704K), 0.0415248 secs]
Total time for which application threads were stopped: 0.0464380 seconds 
  Application time: 0.5114944 seconds
[GC [DefNew: 3968K->64K(4032K), 0.0823952 secs] 3968K->2023K(32704K), 0.0827626 secs]
Total time for which application threads were stopped: 0.0839428 seconds
Application time: 0.9871271 seconds
[GC [DefNew: 4020K->64K(4032K), 0.0412448 secs] 5979K->2374K(32704K), 0.0415248 secs]
Total time for which application threads were stopped: 0.0464380 seconds 
   
   
  Young Generation 的Minor收集占用的时间可以计算如下： 
   
   应用线程被中断的总时常/（应用执行总时?L+应用线程被中断的总时常），那么在本例中垃圾收集占用的时?L约为系统的5％~14％。那么当垃圾收集占用的时间的比例越大的时候，系统的响应将越慢。 
   提示：对于互联网应用系统的响应稍微慢一些，用户是可以接受的，但是对于GUI类型的应用响应速度慢将会给用户带来非常不好的体验。 
    
    
  例4：如何决定Tenured Generation 的大小  
   
    
   
  分别以-Xmn8m -Xmx32m和-Xmn8m -Xmx64m进行对比，先执行 
   
    
  java -verbose:gc -Xmn8m -Xmx32m-XX:+PririntGCDetails -XX:+PrintGCTimeStamps java类 
  java -verbose:gc -Xmn8m -Xmx32m-XX:+PririntGCDetails -XX:+PrintGCTimeStamps java类 
   
   命令行将提示（只提取了Major收集） 
   
    
  111.042: [GC 111.042: [DefNew: 8128K->8128K(8128K), 0.0000505 secs]111.042: [Tenured: 18154K->2311K(24576K), 0.1290354 secs] 26282K->2311K(32704K), 0.1293306 secs]
122.463: [GC 122.463: [DefNew: 8128K->8128K(8128K), 0.0000560 secs]122.463: [Tenured: 18630K->2366K(24576K), 0.1322560 secs] 26758K->2366K(32704K), 0.1325284 secs]
133.896: [GC 133.897: [DefNew: 8128K->8128K(8128K), 0.0000443 secs]133.897: [Tenured: 18240K->2573K(24576K), 0.1340199 secs] 26368K->2573K(32704K), 0.1343218 secs]
144.112: [GC 144.112: [DefNew: 8128K->8128K(8128K), 0.0000544 secs]144.112: [Tenured: 16564K->2304K(24576K), 0.1246831 secs] 24692K->2304K(32704K), 0.1249602 secs] 
  111.042: [GC 111.042: [DefNew: 8128K->8128K(8128K), 0.0000505 secs]111.042: [Tenured: 18154K->2311K(24576K), 0.1290354 secs] 26282K->2311K(32704K), 0.1293306 secs]
122.463: [GC 122.463: [DefNew: 8128K->8128K(8128K), 0.0000560 secs]122.463: [Tenured: 18630K->2366K(24576K), 0.1322560 secs] 26758K->2366K(32704K), 0.1325284 secs]
133.896: [GC 133.897: [DefNew: 8128K->8128K(8128K), 0.0000443 secs]133.897: [Tenured: 18240K->2573K(24576K), 0.1340199 secs] 26368K->2573K(32704K), 0.1343218 secs]
144.112: [GC 144.112: [DefNew: 8128K->8128K(8128K), 0.0000544 secs]144.112: [Tenured: 16564K->2304K(24576K), 0.1246831 secs] 24692K->2304K(32704K), 0.1249602 secs] 
   
   再执行 
   
    
  java -verbose:gc -Xmn8m -Xmx64m-XX:+PririntGCDetails -XX:+PrintGCTimeStamps java类 
  java -verbose:gc -Xmn8m -Xmx64m-XX:+PririntGCDetails -XX:+PrintGCTimeStamps java类 
   
   
   
   命令行将提示（只提取了Major收集） 
  90.597: [GC 90.597: [DefNew: 8128K->8128K(8128K), 0.0000542 secs]90.597: [Tenured: 49841K->5141K(57344K), 0.2129882 secs] 57969K->5141K(65472K), 0.2133274 secs]
120.899: [GC 120.899: [DefNew: 8128K->8128K(8128K), 0.0000550 secs]120.899: [Tenured: 50384K->2430K(57344K), 0.2216590 secs] 58512K->2430K(65472K), 0.2219384 secs]
153.968: [GC 153.968: [DefNew: 8128K->8128K(8128K), 0.0000511 secs]153.968: [Tenured: 51164K->2309K(57344K), 0.2193906 secs] 59292K->2309K(65472K), 0.2196372 secs] 
  90.597: [GC 90.597: [DefNew: 8128K->8128K(8128K), 0.0000542 secs]90.597: [Tenured: 49841K->5141K(57344K), 0.2129882 secs] 57969K->5141K(65472K), 0.2133274 secs]
120.899: [GC 120.899: [DefNew: 8128K->8128K(8128K), 0.0000550 secs]120.899: [Tenured: 50384K->2430K(57344K), 0.2216590 secs] 58512K->2430K(65472K), 0.2219384 secs]
153.968: [GC 153.968: [DefNew: 8128K->8128K(8128K), 0.0000511 secs]153.968: [Tenured: 51164K->2309K(57344K), 0.2193906 secs] 59292K->2309K(65472K), 0.2196372 secs] 
   
   可以看出在Heap size 为32m的时候系统等候时间约为0.13秒左右，而设置为64m的时候等候时间则增大到0.22秒左右了。但是在32m的时候系统的Major收集间隔为 10秒左右，而Heap size 增加到64m的时候为30秒。那么应用在运行的时候是选择32m还是64m呢？ 
  如果应用是web类型（即要求有大的吞吐量）的应用则使用64m（即 heapsize大一些）的比较好。对于要求实时响应要求较高的场合（例如GUI型的应用）则使用32m比较好一些。  
   
  注意： 1。因为在JVM5运行时已经对Heap-size进行了优化，所以在能确定java应用运行时不会超过默认的Heap size的情况下建议不要对这些值进行修改。 2。 Heap size的 -Xms -Xmn 设置不要超出物理内存的大小。否则会提示“Error occurred during initialization of VM Could not reserve enough space for object heap”。 
   
    
    
  例5:如何缩短minor收集的时间  
   
    
   
  下面比较一下采用-XX:+UseParNewGC选项和不采用它的时候的minor收集将有什么不同。先执行 
  java -jar -server -verbose:gc -Xmn8m -Xms32m -Xmx32m SwingSet2.jar 
  java -jar -server -verbose:gc -Xmn8m -Xms32m -Xmx32m SwingSet2.jar  
   
   系统将输出如下信息（片段〕 
   
  [GC 7807K->2641K(32576K), 0.0676654 secs]
[GC 10436K->3108K(32576K), 0.0245328 secs]
[GC 10913K->3176K(32576K), 0.0072865 secs]
[GC 10905K->4097K(32576K), 0.0223928 secs] 
  [GC 7807K->2641K(32576K), 0.0676654 secs]
[GC 10436K->3108K(32576K), 0.0245328 secs]
[GC 10913K->3176K(32576K), 0.0072865 secs]
[GC 10905K->4097K(32576K), 0.0223928 secs] 
   
   之后再执行  
   
    
  java -jar -server -verbose:gc -XX:+UseParNewGC -Xmn8m -Xms32m -Xmx32m SwingSet2.jar 
  java -jar -server -verbose:gc -XX:+UseParNewGC -Xmn8m -Xms32m -Xmx32m SwingSet2.jar 
   
   系统将输出如下信息（片段〕 
   
  [ParNew 7808K->2656K(32576K), 0.0447687 secs]
[ParNew 10441K->3143K(32576K), 0.0179422 secs]
[ParNew 10951K->3177K(32576K), 0.0031914 secs]
[ParNew 10985K->3867K(32576K), 0.0154991 secs] 
  [ParNew 7808K->2656K(32576K), 0.0447687 secs]
[ParNew 10441K->3143K(32576K), 0.0179422 secs]
[ParNew 10951K->3177K(32576K), 0.0031914 secs]
[ParNew 10985K->3867K(32576K), 0.0154991 secs] 
   
   
  很显然使用了-XX:+UseParNewGC选项的minor收集的时间要比不使用的时候优。 
   
    
    
  例6:如何缩短major收集的时间  
   
    
   
  下面比较一下采用-XX:+UseConcMarkSweepGC选项和不采用它的时候的major收集将有什么不同。先执行 
  java -jar -verbose:gc -XX:+UseConcMarkSweepGC -XX:+UseParNewGC -Xmn64m -Xms256m -Xmx256m SwingSet2.jar 
  java -jar -verbose:gc -XX:+UseConcMarkSweepGC -XX:+UseParNewGC -Xmn64m -Xms256m -Xmx256m SwingSet2.jar 
   
   系统将输出如下信息（片段〕 
   
  [Full GC 22972K->18690K(262080K), 0.2326676 secs]
[Full GC 18690K->18690K(262080K), 0.1701866 secs 
  [Full GC 22972K->18690K(262080K), 0.2326676 secs]
[Full GC 18690K->18690K(262080K), 0.1701866 secs 
   
   之后再执行  
   
    
  java -jar -verbose:gc -XX:+UseParNewGC -Xmn64m -Xms256m -Xmx256m SwingSet2.jar 
  java -jar -verbose:gc -XX:+UseParNewGC -Xmn64m -Xms256m -Xmx256m SwingSet2.jar 
   
   系统将输出如下信息（片段〕 
   
  [Full GC 56048K->18869K(260224K), 0.3104852 secs] 
  [Full GC 56048K->18869K(260224K), 0.3104852 secs] 
   
   
  提示：此选项在Heap Size 比较大而且Major收集时间较长的情况下使用更合适。 
   
    
  例7:关于-server选项 
   
    
   
    在JVM中将运行中的类认定为server-class的时候使用此选项。SUN 的Hot Spot JVM5 如果判断到系统的配置满足如下条件则自动将运行的类认定为server-class，并且会自动设置jvm的选项（当没有手工设置这选项的时候〕而且 HOTSPOT JVM5提供了自动调优的功能，他会根据JVM的运行情况进行调整。如果没有特别的需要是不需要太多的人工干预的。SUN形象的称这个机制为“人体工学 ”（Ergonomics〕。具体可以参考http://java.sun.com/docs/hotspot/gc5.0/ergo5.html *.具有2个或更多个物理的处理器 *.具有2G或者更多的物理内存提示：此选项要放在所有选项的前面。例如：java -server 其他选项 java类 
  

                            
                        
                    
                    
                    
                    
                    
                    
                
                
                    
                        
                        
                             
                        
                        
                        
                            
                        
                        
                        
                            
                        
                    
                
            
        
    
    
        你可能感兴趣的:(JVM虚拟机)
        
            
                
                    synchronized锁升级过程
                        liang8999
javajvm开发语言
                        一、synchronized锁加到什么地方synchronized上锁，其实锁信息是加在对象头中的markdown，对象中的前四个字节表示markdown；markdown还记录了对象的gc、hashcode信息注意：markdown结构与jvm虚拟机的实现有关，I）32位Hotspot虚拟机markdown结构如下：II）64位Hotspot虚拟机的markdown结构如下：二、synchron
                    
                    JVM是什么？
                        .suki...
JVM1024程序员节
                        JVM是java虚拟机栈，用于运行java执行字节码文件的。是java实现跨平台的核心机制，因为它的目的是使用相同的字节码文件，在不同的操作系统运行的结果相同。一、java内存模型在JDK1.8之前，它是分为线程共享和线程私有的，在线程共享的部分分为堆区和方法区；在线程私有的部分分为jvm虚拟机栈、程序计数器、本地方法栈。在1.8之后，它是将方法区换为元空间。jvm虚拟机栈：是由一个个的栈帧组成，
                    
                    JAVA的学习Day1
                        Miketutu
java
                        一：JRE和JDK1.JDK是什么？有哪些内容组成JDK是java开发工具包JVM虚拟机：java程序运行的地方核心类库：java已经写好的东西，我们可以直接使用开发工具：javac，java，jdb，jhat2.JRE是什么？有哪些内容组成？JRE是java运行环境JVM、核心类库、运行工具3.JDK,JRE,JVM三者的包含关系JDK包含JREJRE包含JVM二：JAVA基础语法2.1注释2.
                    
                    JAVA面试虚拟机篇
                        是程序喵呀
Javajava面试开发语言
                        1.JVM内存结构要求掌握JVM内存结构划分尤其要知道方法区、永久代、元空间的关系结合一段java代码的执行理解内存划分执行javac命令编译源代码为字节码执行java命令创建JVM，调用类加载子系统加载class，将类的信息存入方法区创建main线程，使用的内存区域是JVM虚拟机栈，开始执行main方法代码如果遇到了未见过的类，会继续触发类加载过程，同样会存入方法区需要创建对象，会使用堆内存来存
                    
                    Java后端开发三年，你不得不了解的JVM
                        zwb_jianshu

                        喜欢的朋友可以关注下专栏：Java架构技术进阶。里面有大量batj面试题集锦，还有各种技术分享，如有好文章也欢迎投稿哦。JAVA程序员，三年是个坎，如果过了三年你还没有去研究JVM的话，那么你这个程序员只能是板砖的工具了。下面来个JVM的解析可好？JVM是JavaVirtualMachine（Java虚拟机）的缩写，也就是指的JVM虚拟机，属于是一种虚构出来的计算机，在我们实际的电脑上来进行模拟各
                    
                    android游戏编程之从零开始！JVM虚拟机原理深入解析，看这一篇就够了！
                        安卓小希
程序员android
                        前言作为一个3-5年的Android工程师，我们经常会遇到这些瓶颈：1.技术视野窄长期在小型软件公司，外包公司工作，技术视野被限制的太厉害2.薪资提升难初中级Android岗位薪资上升空间有限，基本上你想拿15k以上，不会点源码层的东西是根本拿不到的3.学习资源少入门之后想要提升很难，靠自己接触的简单业务项目，去反复操练那些cv技术。博客和书本上的技术大多比较抽象并且零散，可以借鉴和指导，但是没办
                    
                    JVM虚拟机面试题
                        小白频道
JVMjava面试开发语言
                        1入门部分1.1为什么要学习JVM？学习JVM主要有两方面的原因：1.从自身利益出发来讲，学习JVM主要是因为中高级程序员在面试时会提到相关问题。2.从提升自身技术水平来讲，深入理解JVM可以帮助我们从平台的角度去提高解决问题的能力。例如（1）有效防止内存泄漏(Memoryleak)（2）优化线程锁的使用(ThreadLock)（3）科学进行垃圾回收(Garbagecollection)（4）提高
                    
                    Java的一些部分基础知识竟然这么多？
                        小陈从不会敲代码
JAVA初阶javapython开发语言
                        前言Hello，大家好，我是小陈，前几天学了些Java的部分基础知识，发现了自己的许多不足，还有一些根本没听过的知识，与我当下学习的C语言也有部分区别，各个编程语言是相通的，今天就分享给大家。Java语言的特性1.Java语言是面向对象的（oop）。2.Java语言是健壮的。3.Java语言是跨平台性的（Mac,Windows,Linux)。4,Java语言是解释型的。5.因为有了JVM虚拟机，J
                    
                    GitHub获120k+star的阿里内网“疯传”葵花宝典JVM虚拟机调优指南
                        写代码的珏秒秒
Java编程程序员jvmjava算法
                        jvm性能调优都做了什么？JVM性能调优有很多设置,这个参考JVM参数即可.主要调优的目的:控制GC的行为.GC是一个后台处理,但是它也是会消耗系统性能的,因此经常会根据系统运行的程序的特性来更改GC行为控制JVM堆栈大小.一般来说,JVM在内存分配上不需要你修改,(举例)但是当你的程序新生代对象在某个时间段产生的比较多的时候,就需要控制新生代的堆大小.同时,还要需要控制总的JVM大小避免内存溢出
                    
                    Install Kafka on Ubuntu 16
                        华阳_3bcf

                        0准备模拟生产环境，安装Kafka，需要最少三台机器，如下主机名IPKafka-110.0.0.5Kafka-210.0.0.6Kafka-310.0.0.7Kafka是使用scala编写的运行与jvm虚拟机上的程序，一般运行在linux服务器上，首先确保你的机器上安装了jdk，kafka需要java运行环境。以前的kafka还需要zookeeper，新版的kafka已经内置了一个zookeepe
                    
                    JVM虚拟机掌握和优化
                        Leo_Hu666
JVMjvm
                        第一部分：基础一、JVM初始认知一、Java文件编译的过程：1.程序员编写的.java文件2.由javac编译成字节码文件.class：（为什么编译成class文件，因为JVM只认识.class文件）3.在由JVM编译成电脑认识的文件（对于电脑系统来说文件代表一切）二、Java是跨平台语言：1.这个夸平台是中间语言（JVM）实现的夸平台java有JVM从软件层面屏蔽了底层硬件、指令层面的细节让他兼
                    
                    classLoader类加载器如何加载class
                        爱编程的大白

                        ClassLoader翻译过来就是类加载器，普通的java开发者其实用到的不多，但对于某些框架开发者来说却非常常见。理解ClassLoader的加载机制，也有利于我们编写出更高效的代码。ClassLoader的具体作用就是将class文件加载到jvm虚拟机中去，程序就可以正确运行了。但是，jvm启动的时候，并不会一次性加载所有的class文件，而是根据需要去动态加载。想想也是的，一次性加载那么多j
                    
                    （！待更）JVM虚拟机面试题：垃圾回收机制（对象什么时候可以被垃圾器回收、定位垃圾的两种方法、哪些对象可以作为GC Root、垃圾回收算法有哪些、垃圾回收三种算法对比总结）
                        鸡鸭扣
java虚拟机jvm算法java面试后端
                        对象什么时候会被垃圾器回收如果一个或多个对象没有任何的引用指向它了，那么这个对象现在就是垃圾，如果定位到了这个垃圾，则有可能会被垃圾回收器回收。定位垃圾定位垃圾有两种算法，一个是引用计数法，一个是可达性分析算法。引用计数法一个对象被引用了一次，在当前的对象头上递增一次引用次数，如果这个对象的引用次数为0，代表这个对象可回收。但是当对象间出现了循环引用的话，则引用计数法就会失效并可能产生内存泄漏，譬
                    
                    Java程序的开发过程
                        在远方的你等我

                        Java程序的开发过程字节码文件（.class）是与平台无关的二进制码，执行时有解释器（JVM虚拟机完成）解释成本地机器码，解释一句，执行一句。一个.java的文件，经过（javac命令）编译，形成一个.class的字节码文件，然后（java命令）执行在JVM上。因为有了JVM，同一个Java程序在三个不同的操作系统中都可以执行。这样就实现了Java程序的跨平台性。步骤：编写源文件（记事本），编译
                    
                    JAVA虚拟机
                        蓝白汤姆
java开发语言
                        文章目录虚拟机概念系统虚拟机程序虚拟机Java虚拟机JVM介绍JVM虚拟机作用JVM虚拟机特点JVM位置JVM加载类类文件数据类型类文件结构JVM类加载机制类加载过程加载链接-验证链接-准备链接-解析初始化类加载器BootstrapClassLoader(启动类加载器)ExtensionClassLoader(扩展类加载器)AppClassLoader(应用/系统类加载器)自定义类加载器双亲委托模
                    
                    Windows平台程序和Android平台程序的差异
                        carlshen8
Androidwindowsandroid
                        Windows平台程序和Android平台程序的差异1Windows平台环境和Android平台JVM虚拟机的差异：1）由于JVM虚拟机上的数据是大端处理的，而Windows平台上的数据是小端的，所以在一些数据的处理上需要进行转换；2）由于JVM虚拟机上的数据类型都是无符号的，而Windows平台上的数据类型是区分符号和无符号的，所以一些无符号数据类型需要进行特殊的处理；3）Windows平台上的
                    
                    jvm虚拟机
                        胖子爱猪蹄

                        1.演示stack、永久区、堆2.演示两种传引用对象的方法Requestrequest=newRequest();Loginlogin=newLogin();Responseresponse=login.doGet(request);response.toString();Requestrequest=newRequest();Responseresponse=newResponse();Logi
                    
                    双非本科准备秋招（4）——力扣链表与java基础
                        随心自风流
leetcode链表java求职招聘
                        LeetCode基础链表题java操作链表的时候要比c++方便一些，因为c++需要自己手动释放资源，而jvm虚拟机具有垃圾回收机制（GC），如果这个对象将来没被引用过，就会自动回收其所占用的内存。LeetCode上的链表结构不是定义的集合形式，而是结点形式，什么意思呢，举个例子。publicclassSinglyLinkedListSentinel{privateNodehead=newNode(
                    
                    【JVM故障问题排查心得】「Java技术体系方向」Java虚拟机内存优化之虚拟机参数调优原理介绍
                        洛神灬殇
深入浅出Java原理及实战#深入浅出JVM原理及调优jvmjava开发语言
                        Java技术体系方向-JVM虚拟机参数调优原理内容简介栈上分配与逃逸分析逃逸分析(EscapeAnalysis)栈上分配基本思想使用场景线程私有对象虚拟机内存逻辑图JVM内存分配源码：代码总体逻辑在某些场景使用栈上分配设置JVM运行参数：开启逃逸模式，关闭TLAB运行结果查看内存使用情况：结论调整JVM运行参数关闭逃逸模式，开启TLAB查看内存使用情况：运行结果结论调整JVM运行参数关闭逃逸，关闭
                    
                    LeakCanary原理从0到1
                        d袋鼠b
AndroidJVM虚拟机AndroidLeakCanary内存分析
                        文章目录引用分类强引用软引用弱引用虚引用LeakCanary理论依据源码解析LeakCanary2.0的初始化放在了自带的ContentProvider中:为了使文章尽量通俗易懂。在探究LeakCanary之前，有必要补充些Java引用的知识。引用分类强引用强引用是使用最普遍的引用。一个对象具有强引用，则在GC发生时，该对象将不会回收。当Jvm虚拟机内存空间不足时，虚拟机会抛出OutOfMemor
                    
                    守护线程
                        夜夜夜夜_d7e6

                        概念线程分为守护线程和非守护线程。守护线程是指在程序运行的时候在后台提供一种服务的线程，比如垃圾回收线程就是一个守护线程；当所有的非守护线程结束时，程序也就终止了，同时会杀死进程中的所有守护线程。反过来说，只要任何非守护线程还在运行，程序就不会终止守护线程和非守护线程不同之处在于JVM虚拟机的结束:如果非守护线程已经全部结束，只剩下守护线程存在了，虚拟机也就退出了。因为没有了被守护者，守护线程也就
                    
                    扒一扒，类加载的幕后
                        Android之禅

                        前些天写了《Java字节码「随身手册」》及《如何读懂晦涩的Class文件》两篇文章，主要从字节码方面了解类的构成。这篇文章则从JVM加载字节码文件的时机及类加载流程来认识内存中类的生命周期。阅读本文你能收获到掌握JVM何时加载一个类掌握类的生命周期类加载时机Java源文件通过编译器编译转化为Class文件，这些Class文件包含着JVM虚拟机指令及程序运行的逻辑。而类加载器根据类文件全限定名来读取
                    
                    JVM虚拟机
                        新起之猿
jvm
                        JVM概述对Java程序的运行过程更加了解，中、高级程序员必备技能。JVM作用：jvm负责将字节码文件加载到虚拟机中，再将字节码文件，解释\编译为机器码，管理运算时数据存储，垃圾回收（GC）；现在的jvm还可以执行其他语言编译后的字节码文件。JVM构成类加载系统：负责从硬盘上加载字节码文件到JVM中运行时数据区：按照不同的数据分区进行存储(方法区,堆,栈,本地方法栈,程序计数器)执行引擎：将字节码
                    
                    深入理解ClassLoader加载机制
                        碎念枫子

                        ClassLoad类加载器概述ClassLoader的具体作用就是将class文件加载到jvm虚拟机中去，程序就可以正确运行了。jvm启动的时候，并不会一次性加载所有的class文件，而是在程序的运行中动态的去加载。通常Java中的.class文件会在以下两种情况被ClassLoader加载到内存中：调用类构造器调用类中的静态变量或静态方法类的加载指的是将类的.class文件中的二进制数据读入到内
                    
                    理解JVM虚拟机的工作原理
                        Just do Java
Javajvm
                        理解JVM虚拟机的工作原理什么是JVM？是运行所有Java程序的抽象计算机，运行所有Java程序的抽象计算机，是Java语言的运行环境，它是Java最具吸引力的特性之一。虚拟机jvm就是一个操作系统中的进程实例。JVM的内存模型堆所有对象都在这里分配内存，是垃圾回收的主要区域。方法区用于存放加载的类信息、常量、静态变量、即时编译后的代码等数据。运行时常量池Class文件的常量池，会在类加载后被放入
                    
                    瑞_JVM虚拟机_概述
                        瑞486
#jvmjvmjava
                        文章目录1什么是JVM1.1JVM功能1.2常见的JVM1.3常见的JVM:Java虚拟机规范1.4常见的JVM-HotSpot的发展历程2JVM的组成3字节码文件的打开方式3.1以正确的姿势打开字节码.class文件3.1.1NotePad++的插件HexEditor3.1.2jclasslib3.1.3IDEA插件jclasslib4字节码文件的组成4.0常见的字节码指令（持续更新...）4.
                    
                    Java技术栈 —— JVM虚拟机
                        键盘国治理专家
Java技术栈javajvm开发语言
                        JVM虚拟机一、字节码(Byte-Code)1.1如何查看字节码？1.2如何理解字节码的作用？二、JVM内存模型（极其重点，必须牢牢把握住）2.1方法区2.2虚拟机栈2.3本地方法栈2.4堆2.5程序计数器2.6面试必问三、GC机制四、JVM执行引擎4.1解释器与JIT(Just-In-Time)编译器4.2双亲委派和类加载器一、字节码(Byte-Code)1.1如何查看字节码？字节码是一种中间状
                    
                    Java 类加载器学习
                        CSeroad

                        前言类加载器属于JVM的一个重要知识点，也是Java安全里命令执行、webshell管理器编写的常用技术。类加载器简介我们知道java源文件在运行前会被编译为class类文件，存放着编译后JVM虚拟机指令的二进制字节流。当使用某类时，JVM就会加载它并在内存中创建对应的class对象。该过程称为类的加载。类加载过程过程如下：image.png加载阶段通过一个类的完全限定名称来查找该类的字节码文件，
                    
                    记录JVM的学习
                        花里胡哨的菜只因
jvm学习
                        JVM虚拟机常用参数：在虚拟机中输入java就可以启动一个java虚拟机，以横杠开头的都是标准参数；以-X开头的都是非标准参数，当在系统中输入java-X的时候，系统会把所有的非标准参数都列举出来;一般真正用来调优的参数是以-XX开头的标准参数：非标准参数：真正调优的时候用到的参数GC常用参数-Xmn-Xms-Xmx-Xss年轻代最小堆最大堆栈空间-XX:+UseTLAB使用TLAB,默认打开-X
                    
                    IDEA中启动项目报堆内存溢出或者没有足够内存的错误
                        小灰灰-58
坑吧intellij-ideajavaide
                        1.报错现象java.lang.OutOfMemoryError:Javaheapspace或者Couldnotreserveenoughspaceforobjectheap2.解决办法在运行配置中VM选项后加下面的配置：-server-XX:MaxHeapSize=256m-Xms512m-Xmx512m-XX:PermSize=128M-XX:MaxPermSize=256m3.JVM虚拟机配
                    
                                Java实现的简单双向Map，支持重复Value
                                    superlxw1234
java双向map
                                    关键字：Java双向Map、DualHashBidiMap 
  
  
有个需求，需要根据即时修改Map结构中的Value值，比如，将Map中所有value=V1的记录改成value=V2，key保持不变。 
  
数据量比较大，遍历Map性能太差，这就需要根据Value先找到Key，然后去修改。 
  
即：既要根据Key找Value，又要根据Value
                                
                                PL/SQL触发器基础及例子
                                    百合不是茶
oracle数据库触发器PL/SQL编程
                                      
触发器的简介; 
触发器的定义就是说某个条件成立的时候，触发器里面所定义的语句就会被自动的执行。因此触发器不需要人为的去调用，也不能调用。触发器和过程函数类似 过程函数必须要调用, 
  
一个表中最多只能有12个触发器类型的,触发器和过程函数相似 触发器不需要调用直接执行,


 
触发时间：指明触发器何时执行，该值可取：
before：表示在数据库动作之前触发
                                
                                [时空与探索]穿越时空的一些问题
                                    comsci
问题
                                     
      我们还没有进行过任何数学形式上的证明,仅仅是一个猜想..... 
 
      这个猜想就是; 任何有质量的物体(哪怕只有一微克)都不可能穿越时空,该物体强行穿越时空的时候,物体的质量会与时空粒子产生反应,物体会变成暗物质,也就是说,任何物体穿越时空会变成暗物质..(暗物质就我的理
                                
                                easy ui datagrid上移下移一行
                                    商人shang
js上移下移easyuidatagrid
                                    /**
 * 向上移动一行
 * 
 * @param dg
 * @param row
 */
function moveupRow(dg, row) {
	var datagrid = $(dg);
	var index = datagrid.datagrid("getRowIndex", row);
	if (isFirstRow(dg, row)) {
                                
                                Java反射
                                    oloz
反射
                                    本人菜鸟，今天恰好有时间，写写博客，总结复习一下java反射方面的知识，欢迎大家探讨交流学习指教 
 
首先看看java中的Class 
 
package demo;

public class ClassTest {
	
	/*先了解java中的Class*/
	
	public static void main(String[] args) {
		
    //任何一个类都
                                
                                springMVC 使用JSR-303 Validation验证
                                    杨白白
springmvc
                                    JSR-303是一个数据验证的规范，但是spring并没有对其进行实现，Hibernate Validator是实现了这一规范的，通过此这个实现来讲SpringMVC对JSR-303的支持。 
 JSR-303的校验是基于注解的，首先要把这些注解标记在需要验证的实体类的属性上或是其对应的get方法上。 
 
登录需要验证类 
 
public class Login {

	@NotEmpty
                                
                                log4j
                                    香水浓
log4j
                                    
log4j.rootCategory=DEBUG, STDOUT, DAILYFILE, HTML, DATABASE
#log4j.rootCategory=DEBUG, STDOUT, DAILYFILE, ROLLINGFILE, HTML

#console
log4j.appender.STDOUT=org.apache.log4j.ConsoleAppender
log4
                                
                                使用ajax和history.pushState无刷新改变页面URL
                                    agevs
jquery框架Ajaxhtml5chrome
                                    表现 
如果你使用chrome或者firefox等浏览器访问本博客、github.com、plus.google.com等网站时，细心的你会发现页面之间的点击是通过ajax异步请求的，同时页面的URL发生了了改变。并且能够很好的支持浏览器前进和后退。 
是什么有这么强大的功能呢？ 
HTML5里引用了新的API，history.pushState和history.replaceState，就是通过
                                
                                centos中文乱码
                                    AILIKES
centosOSssh
                                    一、CentOS系统访问 g.cn ，发现中文乱码。 
于是用以前的方式：yum -y install fonts-chinese 
CentOS系统安装后，还是不能显示中文字体。我使用 gedit 编辑源码，其中文注释也为乱码。     
  
      
  
后来，终于找到以下方法可以解决，需要两个中文支持的包： 
fonts-chinese-3.02-12.
                                
                                触发器
                                    baalwolf
触发器
                                    触发器(trigger)：监视某种情况，并触发某种操作。 
触发器创建语法四要素：1.监视地点(table) 2.监视事件(insert/update/delete) 3.触发时间(after/before) 4.触发事件(insert/update/delete) 
语法： 
create trigger triggerName 
after/before 
                                
                                JS正则表达式的i m g
                                    bijian1013
JavaScript正则表达式
                                            g:表示全局（global)模式，即模式将被应用于所有字符串，而非在发现第一个匹配项时立即停止。         i:表示不区分大小写（case-insensitive）模式，即在确定匹配项时忽略模式与字符串的大小写。         m:表示
                                
                                HTML5模式和Hashbang模式
                                    bijian1013
JavaScriptAngularJSHashbang模式HTML5模式
                                            我们可以用$locationProvider来配置$location服务（可以采用注入的方式，就像AngularJS中其他所有东西一样）。这里provider的两个参数很有意思，介绍如下。 
html5Mode 
        一个布尔值，标识$location服务是否运行在HTML5模式下。 
ha
                                
                                [Maven学习笔记六]Maven生命周期
                                    bit1129
maven
                                    从mvn test的输出开始说起 
  
当我们在user-core中执行mvn test时，执行的输出如下： 
  
/software/devsoftware/jdk1.7.0_55/bin/java -Dmaven.home=/software/devsoftware/apache-maven-3.2.1 -Dclassworlds.conf=/software/devs
                                
                                【Hadoop七】基于Yarn的Hadoop Map Reduce容错
                                    bit1129
hadoop
                                    运行于Yarn的Map Reduce作业，可能发生失败的点包括 
 
 Task Failure 
 Application Master Failure 
 Node Manager Failure 
 Resource Manager Failure 
 1. Task Failure 
任务执行过程中产生的异常和JVM的意外终止会汇报给Application Master。僵死的任务也会被A
                                
                                记一次数据推送的异常解决端口解决
                                    ronin47
记一次数据推送的异常解决
                                    　　 需求：从db获取数据然后推送到B 
        程序开发完成，上jboss,刚开始报了很多错，逐一解决，可最后显示连接不到数据库。机房的同事说可以ping 通。 
　　  自已画了个图，逐一排除，把linux 防火墙　和　setenforce　设置最低。 
　　　service iptables stop 

                                
                                巧用视错觉-UI更有趣
                                    brotherlamp
UIui视频ui教程ui自学ui资料
                                    我们每个人在生活中都曾感受过视错觉（optical illusion）的魅力。 
视错觉现象是双眼跟我们开的一个玩笑，而我们往往还心甘情愿地接受我们看到的假象。其实不止如此，视觉错现象的背后还有一个重要的科学原理——格式塔原理。 
格式塔原理解释了人们如何以视觉方式感觉物体，以及图像的结构，视角，大小等要素是如何影响我们的视觉的。 
在下面这篇文章中，我们首先会简单介绍一下格式塔原理中的基本概念，
                                
                                线段树-poj1177-N个矩形求边长（离散化+扫描线）
                                    bylijinnan
数据结构算法线段树
                                    package com.ljn.base;

import java.util.Arrays;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

/**
 * POJ 1177 (线段树+离散化+扫描线)，题目链接为http://poj.org/problem?id=1177

                                
                                HTTP协议详解
                                    chicony
http协议
                                    引言                                 
                                
                                Scala设计模式
                                    chenchao051
设计模式scala
                                    Scala设计模式 
        
       我的话： 在国外网站上看到一篇文章，里面详细描述了很多设计模式，并且用Java及Scala两种语言描述，清晰的让我们看到各种常规的设计模式，在Scala中是如何在语言特性层面直接支持的。基于文章很nice，我利用今天的空闲时间将其翻译，希望大家能一起学习，讨论。翻译
                                
                                安装mysql
                                    daizj
mysql安装
                                    安装mysql 
  (1)删除linux上已经安装的mysql相关库信息。rpm  -e  xxxxxxx   --nodeps (强制删除) 
     执行命令rpm -qa |grep mysql 检查是否删除干净 
  (2)执行命令  rpm -i MySQL-server-5.5.31-2.el
                                
                                HTTP状态码大全
                                    dcj3sjt126com
http状态码
                                    完整的 HTTP 1.1规范说明书来自于RFC 2616，你可以在http://www.talentdigger.cn/home/link.php?url=d3d3LnJmYy1lZGl0b3Iub3JnLw%3D%3D在线查阅。HTTP 1.1的状态码被标记为新特性，因为许多浏览器只支持 HTTP 1.0。你应只把状态码发送给支持 HTTP 1.1的客户端，支持协议版本可以通过调用request
                                
                                asihttprequest上传图片
                                    dcj3sjt126com
ASIHTTPRequest
                                    NSURL *url =@"yourURL";
    ASIFormDataRequest*currentRequest =[ASIFormDataRequest requestWithURL:url];
    [currentRequest setPostFormat:ASIMultipartFormDataPostFormat];[currentRequest se
                                
                                C语言中，关键字static的作用
                                    e200702084
C++cC#
                                    在C语言中，关键字static有三个明显的作用： 
 
1)在函数体，局部的static变量。生存期为程序的整个生命周期，（它存活多长时间）；作用域却在函数体内（它在什么地方能被访问（空间））。 
一个被声明为静态的变量在这一函数被调用过程中维持其值不变。因为它分配在静态存储区，函数调用结束后并不释放单元，但是在其它的作用域的无法访问。当再次调用这个函数时，这个局部的静态变量还存活，而且用在它的访
                                
                                win7/8使用curl
                                    geeksun
win7
                                    1.  WIN7/8下要使用curl，需要下载curl-7.20.0-win64-ssl-sspi.zip和Win64OpenSSL_Light-1_0_2d.exe。  下载地址：  
http://curl.haxx.se/download.html   请选择不带SSL的版本，否则还需要安装SSL的支持包       2.  可以给Windows增加c
                                
                                Creating a Shared Repository; Users Sharing The Repository
                                    hongtoushizi
git
                                    转载自：  
http://www.gitguys.com/topics/creating-a-shared-repository-users-sharing-the-repository/  Commands discussed in this section: 
 
 git init –bare 
 git clone 
 git remote 
 git pull 
 git p
                                
                                Java实现字符串反转的8种或9种方法
                                    Josh_Persistence
异或反转递归反转二分交换反转java字符串反转栈反转
                                    注：对于第7种使用异或的方式来实现字符串的反转，如果不太看得明白的，可以参照另一篇博客： 
http://josh-persistence.iteye.com/blog/2205768 
  
/**
 * 
 */
package com.wsheng.aggregator.algorithm.string;

import java.util.Stack;

/**

                                
                                代码实现任意容量倒水问题
                                    home198979
PHP算法倒水
                                    形象化设计模式实战             HELLO!架构                     redis命令源码解析 
  
倒水问题：有两个杯子，一个A升，一个B升，水有无限多，现要求利用这两杯子装C
                                
                                Druid datasource
                                    zhb8015
druid
                                    推荐大家使用数据库连接池 DruidDataSource. http://code.alibabatech.com/wiki/display/Druid/DruidDataSource DruidDataSource经过阿里巴巴数百个应用一年多生产环境运行验证，稳定可靠。 它最重要的特点是：监控、扩展和性能。 下载和Maven配置看这里： http
                                
                                两种启动监听器ApplicationListener和ServletContextListener
                                    spjich
javaspring框架
                                    引言:有时候需要在项目初始化的时候进行一系列工作，比如初始化一个线程池，初始化配置文件，初始化缓存等等，这时候就需要用到启动监听器，下面分别介绍一下两种常用的项目启动监听器 
  
ServletContextListener  
特点: 依赖于sevlet容器，需要配置web.xml 
使用方法: 
public class StartListener implements 
                                
                                JavaScript Rounding Methods of the Math object
                                    何不笑
JavaScriptMath
                                        The next group of methods has to do with rounding decimal values into integers. Three methods — Math.ceil(),  Math.floor(), and  Math.round() — handle rounding in differen
                                
                
            
        
    


    
        
            按字母分类：
            ABCDEFGHIJKLMNOPQRSTUVWXYZ其他
        
    


    
        
            首页 -
            关于我们 -
            站内搜索 -
            Sitemap -
            侵权投诉
        
        版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.