• jvm运行参数


    我们为什么要对jvm做优化?

    在本地开发环境中我们很少会遇到需要对jvm进行优化的需求,但是到了生产环境,我们可能将有下面的需求:
      运行的应用“卡住了”,日志不输出,程序没有反应
      服务器的CPU负载突然升高
      在多线程应用下,如何分配线程的数量?

    jvm的运行参数

    在jvm中有很多的参数可以进行设置,这样可以让jvm在各种环境中都能够高效的运行。 绝大部分的参数保持默认即可。

    三种参数类型

    jvm的参数类型分为三类,分别是:
      标准参数
        -help
        -version
      -X参数 (非标准参数)
        -Xint
        -Xcomp
      -XX参数(使用率较高)
        -XX:newSize
        -XX:+UseSerialGC

    标准参数

    jvm的标准参数,一般都是很稳定的,在未来的JVM版本中不会改变,可以使用java -help 检索出所有的标准参数。

    用法: java [-options] class [args...]
               (执行类)
       或  java [-options] -jar jarfile [args...]
               (执行 jar 文件)
    其中选项包括:
        -d32          使用 32 位数据模型 (如果可用)
        -d64          使用 64 位数据模型 (如果可用)
        -client       选择 "client" VM
        -server       选择 "server" VM
                      默认 VM 是 client.
    
        -cp <目录和 zip/jar 文件的类搜索路径>
        -classpath <目录和 zip/jar 文件的类搜索路径>
                      用 ; 分隔的目录, JAR 档案
                      和 ZIP 档案列表, 用于搜索类文件。
        -D<名称>=<值>
                      设置系统属性
        -verbose:[class|gc|jni]
                      启用详细输出
        -version      输出产品版本并退出
        -version:<值>
                      警告: 此功能已过时, 将在
                      未来发行版中删除。
                      需要指定的版本才能运行
        -showversion  输出产品版本并继续
        -jre-restrict-search | -no-jre-restrict-search
                      警告: 此功能已过时, 将在
                      未来发行版中删除。
                      在版本搜索中包括/排除用户专用 JRE
        -? -help      输出此帮助消息
        -X            输出非标准选项的帮助
        -ea[:<packagename>...|:<classname>]
        -enableassertions[:<packagename>...|:<classname>]
                      按指定的粒度启用断言
        -da[:<packagename>...|:<classname>]
        -disableassertions[:<packagename>...|:<classname>]
                      禁用具有指定粒度的断言
        -esa | -enablesystemassertions
                      启用系统断言
        -dsa | -disablesystemassertions
                      禁用系统断言
        -agentlib:<libname>[=<选项>]
                      加载本机代理库 <libname>, 例如 -agentlib:hprof
                      另请参阅 -agentlib:jdwp=help 和 -agentlib:hprof=help
        -agentpath:<pathname>[=<选项>]
                      按完整路径名加载本机代理库
        -javaagent:<jarpath>[=<选项>]
                      加载 Java 编程语言代理, 请参阅 java.lang.instrument
        -splash:<imagepath>
                      使用指定的图像显示启动屏幕

    查看JVM的版本

    [root@node01 ~]# java ‐version 
    java version "1.8.0_73" 
    Java(TM) SE Runtime Environment (build 1.8.0_73‐b15) 
    Java HotSpot(TM) 64‐Bit Server VM (build 25.73‐b15, mixed mode)

    通过-D设置系统属性参数

    public class TestJVM { 
        public static void main(String[] args) { 
            String str = System.getProperty("str"); 
            if (str == null) { 
                System.out.println("jvmTest"); 
            } else { 
                System.out.println(str); 
            } 
        } 
    }

    进行编译、测试

    #编译
    javac JvmTest.java
    #运行
    java JvmTest
    #修改str值为JVM
    java -Dstr=JVM JvmTest

    -server与-client参数 

        可以通过-server或-client设置jvm的运行参数。
        它们的区别是Server VM的初始堆空间会大一些,默认使用的是并行垃圾回收器,启动慢运行快。
        Client VM相对来讲会保守一些,初始堆空间会小一些,使用串行的垃圾回收器,它的目标是为了让JVM的启动速度更快,但运行速度会比Serverm模式慢些。
        JVM在启动的时候会根据硬件和操作系统自动选择使用Server还是Client类型的JVM。
      32位操作系统
        如果是Windows系统,不论硬件配置如何,都默认使用Client类型的JVM。
        如果是其他操作系统上,机器配置有2GB以上的内存同时有2个以上CPU的话默认使用server模式,否则使用client模式。
      64位操作系统
        只有server类型,不支持client类型。
      测试:

     
    [root@node01 test]# java ‐client ‐showversion TestJVM 
    java version "1.8.0_73" 
    Java(TM) SE Runtime Environment (build 1.8.0_73‐b15) 
    Java HotSpot(TM) 64‐Bit Server VM (build 25.141‐b15, mixed mode) 
    itcast 
    [root@node01 test]# java ‐server ‐showversion TestJVM 
    java version "1.8.0_73" 
    Java(TM) SE Runtime Environment (build 1.8.0_73‐b15) 
    Java HotSpot(TM) 64‐Bit Server VM (build 25.141‐b15, mixed mode) 
    itcast 
    #由于机器是64位系统,所以不支持client模式

    -X参数
      JVM的-X参数是标椎参数,在不同的版本的JVM中,参数可能有所不同,可以通过java -X查看非标椎参数;

    C:Usersjvm>java -X
        -Xmixed           混合模式执行 (默认)
        -Xint             仅解释模式执行
        -Xbootclasspath:<用 ; 分隔的目录和 zip/jar 文件>
                          设置搜索路径以引导类和资源
        -Xbootclasspath/a:<用 ; 分隔的目录和 zip/jar 文件>
                          附加在引导类路径末尾
        -Xbootclasspath/p:<用 ; 分隔的目录和 zip/jar 文件>
                          置于引导类路径之前
        -Xdiag            显示附加诊断消息
        -Xnoclassgc       禁用类垃圾收集
        -Xincgc           启用增量垃圾收集
        -Xloggc:<file>    将 GC 状态记录在文件中 (带时间戳)
        -Xbatch           禁用后台编译
        -Xms<size>        设置初始 Java 堆大小
        -Xmx<size>        设置最大 Java 堆大小
        -Xss<size>        设置 Java 线程堆栈大小
        -Xprof            输出 cpu 配置文件数据
        -Xfuture          启用最严格的检查, 预期将来的默认值
        -Xrs              减少 Java/VM 对操作系统信号的使用 (请参阅文档)
        -Xcheck:jni       对 JNI 函数执行其他检查
        -Xshare:off       不尝试使用共享类数据
        -Xshare:auto      在可能的情况下使用共享类数据 (默认)
        -Xshare:on        要求使用共享类数据, 否则将失败。
        -XshowSettings    显示所有设置并继续
        -XshowSettings:all
                          显示所有设置并继续
        -XshowSettings:vm 显示所有与 vm 相关的设置并继续
        -XshowSettings:properties
                          显示所有属性设置并继续
        -XshowSettings:locale
                          显示所有与区域设置相关的设置并继续
    
    -X 选项是非标准选项, 如有更改, 恕不另行通知。

    -Xint、-Xcomp、-Xmixed
        在解释模式(interpreted mode)下,-Xint标记会强制JVM执行所有的字节码,当然这会降低运行速度,通常低10倍或更多。
         -Xcomp参数与它(-Xint)正好相反,JVM在第一次使用时会把所有的字节码编译成本地代码,从而带来最大程度的优化。
          然而,很多应用在使用-Xcomp也会有一些性能损失,当然这比使用-Xint损失的少,原因是-xcomp没有让JVM启用JIT编译器的全部功能。JIT编译器可以对是否需要编译做判断,如果所有代码都进行编译的话,对于一些只执行一次的代码就没有意义了。
        -Xmixed是混合模式,将解释模式与编译模式进行混合使用,由jvm自己决定,这是jvm默认的模式,也是推荐使用的模式。
      #注意:编译模式下,第一次执行会比解释模式下执行慢一些,注意观察。

    #-Xint
    java -showversion -Xint JvmTest
    #-Xcomp
    java -showversion -Xcomp JvmTest
    #默认混合模式
    java -showversion  JvmTest

    -XX参数
      -XX参数也是非标准参数,主要用于jvm的调优和debug操作。
      -XX参数的使用有2种方式,一种是boolean类型,一种是非boolean类型:
      boolean类型
        格式:-XX:[+-]
        如:-XX:+DisableExplicitGC 表示禁用手动调用gc操作,也就是说调用System.gc()无效
      非boolean类型
        格式:-XX:
        如:-XX:NewRatio=1 表示新生代和老年代的比值
      测试:

    java -showversion -XX:+DisableExplicitGC JvmTest

    -Xms与-Xmx参数
      -Xms与-Xmx分别是设置jvm的堆内存的初始大小和最大大小。
      -Xmx2048m:等价于-XX:MaxHeapSize,设置JVM最大堆内存为2048M。
      -Xms512m:等价于-XX:InitialHeapSize,设置JVM初始堆内存为512M。
      适当的调整jvm的内存大小,可以充分利用服务器资源,让程序跑的更快。
      测试:

    java -Xms521m -Xmx1024m JvmTest

     查看jvm的运行参数
      有些时候我们需要查看jvm的运行参数,这个需求可能会存在2种情况:
          第一,运行java命令时打印出运行参数;
       第二,查看正在运行的java进程的参数;

      2.6.1 运行java命令时打印参数

       运行java命令时打印参数,需要添加java -XX:+PrintFlagsFinal -version参数即可。
       参数有boolean类型和数字类型,值的操作符是=或:=,分别代表默认值和被修改的值。

    [Global flags]
        uintx AdaptiveSizeDecrementScaleFactor          = 4                                   {product}
        uintx AdaptiveSizeMajorGCDecayTimeScale         = 10                                  {product}
        uintx AdaptiveSizePausePolicy                   = 0                                   {product}
        uintx AdaptiveSizePolicyCollectionCostMargin    = 50                                  {product}
        uintx AdaptiveSizePolicyInitializingSteps       = 20                                  {product}
        uintx AdaptiveSizePolicyOutputInterval          = 0                                   {product}
        uintx AdaptiveSizePolicyWeight                  = 10                                  {product}
        uintx AdaptiveSizeThroughPutPolicy              = 0                                   {product}
        uintx AdaptiveTimeWeight                        = 25                                  {product}
         bool AdjustConcurrency                         = false                               {product}
         bool AggressiveOpts                            = false                               {product}
         intx AllocateInstancePrefetchLines             = 1                                   {product}
         intx AllocatePrefetchDistance                  = 192                                 {product}
         intx AllocatePrefetchInstr                     = 3                                   {product}
         intx AllocatePrefetchLines                     = 4                                   {product}
         intx AllocatePrefetchStepSize                  = 64                                  {product}
         intx AllocatePrefetchStyle                     = 1                                   {product}
         bool AllowJNIEnvProxy                          = false                               {product}
         bool AllowNonVirtualCalls                      = false                               {product}
         bool AllowParallelDefineClass                  = false                               {product}
         bool AllowUserSignalHandlers                   = false                               {product}
         bool AlwaysActAsServerClassMachine             = false                               {product}
         bool AlwaysCompileLoopMethods                  = false                               {product}
         bool AlwaysLockClassLoader                     = false                               {product}
         bool AlwaysPreTouch                            = false                               {product}
         bool AlwaysRestoreFPU                          = false                               {product}
         bool AlwaysTenure                              = false                               {product}
         bool AssertOnSuspendWaitFailure                = false                               {product}
         bool AssumeMP                                  = false                               {product}
        uintx AutoGCSelectPauseMillis                   = 5000                                {product}
         intx BCEATraceLevel                            = 0                                   {product}
         intx BackEdgeThreshold                         = 100000                              {pd product}
         bool BackgroundCompilation                     = true                                {pd product}
        uintx BaseFootPrintEstimate                     = 268435456                           {product}
         intx BiasedLockingBulkRebiasThreshold          = 20                                  {product}
         intx BiasedLockingBulkRevokeThreshold          = 40                                  {product}
         intx BiasedLockingDecayTime                    = 25000                               {product}
         intx BiasedLockingStartupDelay                 = 4000                                {product}
         bool BindGCTaskThreadsToCPUs                   = false                               {product}
         bool BytecodeVerificationLocal                 = false                               {product}
         bool BytecodeVerificationRemote                = true                                {product}
         bool C1OptimizeVirtualCallProfiling            = true                                {C1 product}
         bool C1ProfileBranches                         = true                                {C1 product}
         bool C1ProfileCalls                            = true                                {C1 product}
         bool C1ProfileCheckcasts                       = true                                {C1 product}
         bool C1ProfileInlinedCalls                     = true                                {C1 product}
         bool C1ProfileVirtualCalls                     = true                                {C1 product}
         bool C1UpdateMethodData                        = false                               {C1 product}
         intx CICompilerCount                           = 1                                   {product}
         bool CICompilerCountPerCPU                     = false                               {product}
         bool CITime                                    = false                               {product}
         bool CMSAbortSemantics                         = false                               {product}
        uintx CMSAbortablePrecleanMinWorkPerIteration   = 100                                 {product}
         intx CMSAbortablePrecleanWaitMillis            = 100                                 {manageable}
        uintx CMSBitMapYieldQuantum                     = 10485760                            {product}
        uintx CMSBootstrapOccupancy                     = 50                                  {product}
         bool CMSClassUnloadingEnabled                  = true                                {product}
        uintx CMSClassUnloadingMaxInterval              = 0                                   {product}
         bool CMSCleanOnEnter                           = true                                {product}
         bool CMSCompactWhenClearAllSoftRefs            = true                                {product}
        uintx CMSConcMarkMultiple                       = 32                                  {product}
         bool CMSConcurrentMTEnabled                    = true                                {product}
        uintx CMSCoordinatorYieldSleepCount             = 10                                  {product}
         bool CMSDumpAtPromotionFailure                 = false                               {product}
         bool CMSEdenChunksRecordAlways                 = true                                {product}
        uintx CMSExpAvgFactor                           = 50                                  {product}
         bool CMSExtrapolateSweep                       = false                               {product}
        uintx CMSFullGCsBeforeCompaction                = 0                                   {product}
        uintx CMSIncrementalDutyCycle                   = 10                                  {product}
        uintx CMSIncrementalDutyCycleMin                = 0                                   {product}
         bool CMSIncrementalMode                        = false                               {product}
        uintx CMSIncrementalOffset                      = 0                                   {product}
         bool CMSIncrementalPacing                      = true                                {product}
        uintx CMSIncrementalSafetyFactor                = 10                                  {product}
        uintx CMSIndexedFreeListReplenish               = 4                                   {product}
         intx CMSInitiatingOccupancyFraction            = -1                                  {product}
        uintx CMSIsTooFullPercentage                    = 98                                  {product}
       double CMSLargeCoalSurplusPercent                = 0.950000                            {product}
       double CMSLargeSplitSurplusPercent               = 1.000000                            {product}
         bool CMSLoopWarn                               = false                               {product}
        uintx CMSMaxAbortablePrecleanLoops              = 0                                   {product}
         intx CMSMaxAbortablePrecleanTime               = 5000                                {product}
        uintx CMSOldPLABMax                             = 1024                                {product}
        uintx CMSOldPLABMin                             = 16                                  {product}
        uintx CMSOldPLABNumRefills                      = 4                                   {product}
        uintx CMSOldPLABReactivityFactor                = 2                                   {product}
         bool CMSOldPLABResizeQuicker                   = false                               {product}
        uintx CMSOldPLABToleranceFactor                 = 4                                   {product}
         bool CMSPLABRecordAlways                       = true                                {product}
        uintx CMSParPromoteBlocksToClaim                = 16                                  {product}
         bool CMSParallelInitialMarkEnabled             = true                                {product}
         bool CMSParallelRemarkEnabled                  = true                                {product}
         bool CMSParallelSurvivorRemarkEnabled          = true                                {product}
        uintx CMSPrecleanDenominator                    = 3                                   {product}
        uintx CMSPrecleanIter                           = 3                                   {product}
        uintx CMSPrecleanNumerator                      = 2                                   {product}
         bool CMSPrecleanRefLists1                      = true                                {product}
         bool CMSPrecleanRefLists2                      = false                               {product}
         bool CMSPrecleanSurvivors1                     = false                               {product}
         bool CMSPrecleanSurvivors2                     = true                                {product}
        uintx CMSPrecleanThreshold                      = 1000                                {product}
         bool CMSPrecleaningEnabled                     = true                                {product}
         bool CMSPrintChunksInDump                      = false                               {product}
         bool CMSPrintEdenSurvivorChunks                = false                               {product}
         bool CMSPrintObjectsInDump                     = false                               {product}
        uintx CMSRemarkVerifyVariant                    = 1                                   {product}
         bool CMSReplenishIntermediate                  = true                                {product}
        uintx CMSRescanMultiple                         = 32                                  {product}
        uintx CMSSamplingGrain                          = 16384                               {product}
         bool CMSScavengeBeforeRemark                   = false                               {product}
        uintx CMSScheduleRemarkEdenPenetration          = 50                                  {product}
        uintx CMSScheduleRemarkEdenSizeThreshold        = 2097152                             {product}
        uintx CMSScheduleRemarkSamplingRatio            = 5                                   {product}
       double CMSSmallCoalSurplusPercent                = 1.050000                            {product}
       double CMSSmallSplitSurplusPercent               = 1.100000                            {product}
         bool CMSSplitIndexedFreeListBlocks             = true                                {product}
         intx CMSTriggerInterval                        = -1                                  {manageable}
        uintx CMSTriggerRatio                           = 80                                  {product}
         intx CMSWaitDuration                           = 2000                                {manageable}
        uintx CMSWorkQueueDrainThreshold                = 10                                  {product}
         bool CMSYield                                  = true                                {product}
        uintx CMSYieldSleepCount                        = 0                                   {product}
        uintx CMSYoungGenPerWorker                      = 67108864                            {pd product}
        uintx CMS_FLSPadding                            = 1                                   {product}
        uintx CMS_FLSWeight                             = 75                                  {product}
        uintx CMS_SweepPadding                          = 1                                   {product}
        uintx CMS_SweepTimerThresholdMillis             = 10                                  {product}
        uintx CMS_SweepWeight                           = 75                                  {product}
         bool CheckEndorsedAndExtDirs                   = false                               {product}
         bool CheckJNICalls                             = false                               {product}
         bool ClassUnloading                            = true                                {product}
         bool ClassUnloadingWithConcurrentMark          = true                                {product}
         intx ClearFPUAtPark                            = 0                                   {product}
         bool ClipInlining                              = true                                {product}
        uintx CodeCacheExpansionSize                    = 32768                               {pd product}
        uintx CodeCacheMinimumFreeSpace                 = 512000                              {product}
         bool CollectGen0First                          = false                               {product}
         bool CompactFields                             = true                                {product}
         intx CompilationPolicyChoice                   = 0                                   {product}
    ccstrlist CompileCommand                            =                                     {product}
        ccstr CompileCommandFile                        =                                     {product}
    ccstrlist CompileOnly                               =                                     {product}
         intx CompileThreshold                          = 1500                                {pd product}
         bool CompilerThreadHintNoPreempt               = true                                {product}
         intx CompilerThreadPriority                    = -1                                  {product}
         intx CompilerThreadStackSize                   = 0                                   {pd product}
        uintx CompressedClassSpaceSize                  = 1073741824                          {product}
        uintx ConcGCThreads                             = 0                                   {product}
         intx ContendedPaddingWidth                     = 128                                 {product}
         bool ConvertSleepToYield                       = true                                {pd product}
         bool ConvertYieldToSleep                       = false                               {product}
         bool CreateMinidumpOnCrash                     = false                               {product}
         bool CriticalJNINatives                        = true                                {product}
         bool DTraceAllocProbes                         = false                               {product}
         bool DTraceMethodProbes                        = false                               {product}
         bool DTraceMonitorProbes                       = false                               {product}
         bool Debugging                                 = false                               {product}
        uintx DefaultMaxRAMFraction                     = 4                                   {product}
         intx DefaultThreadPriority                     = -1                                  {product}
         intx DeferPollingPageLoopCount                 = -1                                  {product}
         intx DeferThrSuspendLoopCount                  = 4000                                {product}
         bool DeoptimizeRandom                          = false                               {product}
         bool DisableAttachMechanism                    = false                               {product}
         bool DisableExplicitGC                         = false                               {product}
         bool DisplayVMOutputToStderr                   = false                               {product}
         bool DisplayVMOutputToStdout                   = false                               {product}
         bool DontCompileHugeMethods                    = true                                {product}
         bool DontYieldALot                             = false                               {pd product}
        ccstr DumpLoadedClassList                       =                                     {product}
         bool DumpReplayDataOnError                     = true                                {product}
         bool DumpSharedSpaces                          = false                               {product}
         bool EagerXrunInit                             = false                               {product}
         intx EmitSync                                  = 0                                   {product}
         bool EnableContended                           = true                                {product}
         bool EnableResourceManagementTLABCache         = true                                {product}
         bool EnableSharedLookupCache                   = true                                {product}
         bool EnableTracing                             = false                               {product}
        uintx ErgoHeapSizeLimit                         = 0                                   {product}
        ccstr ErrorFile                                 =                                     {product}
        ccstr ErrorReportServer                         =                                     {product}
         bool EstimateArgEscape                         = true                                {product}
         bool ExplicitGCInvokesConcurrent               = false                               {product}
         bool ExplicitGCInvokesConcurrentAndUnloadsClasses  = false                               {product}
         bool ExtendedDTraceProbes                      = false                               {product}
        ccstr ExtraSharedClassListFile                  =                                     {product}
         bool FLSAlwaysCoalesceLarge                    = false                               {product}
        uintx FLSCoalescePolicy                         = 2                                   {product}
       double FLSLargestBlockCoalesceProximity          = 0.990000                            {product}
         bool FailOverToOldVerifier                     = true                                {product}
         bool FastTLABRefill                            = true                                {product}
         intx FenceInstruction                          = 0                                   {ARCH product}
         intx FieldsAllocationStyle                     = 1                                   {product}
         bool FilterSpuriousWakeups                     = true                                {product}
        ccstr FlightRecorderOptions                     =                                     {product}
         bool ForceNUMA                                 = false                               {product}
         bool ForceTimeHighResolution                   = false                               {product}
         intx FreqInlineSize                            = 325                                 {pd product}
       double G1ConcMarkStepDurationMillis              = 10.000000                           {product}
        uintx G1ConcRSHotCardLimit                      = 4                                   {product}
        uintx G1ConcRSLogCacheSize                      = 10                                  {product}
         intx G1ConcRefinementGreenZone                 = 0                                   {product}
         intx G1ConcRefinementRedZone                   = 0                                   {product}
         intx G1ConcRefinementServiceIntervalMillis     = 300                                 {product}
        uintx G1ConcRefinementThreads                   = 0                                   {product}
         intx G1ConcRefinementThresholdStep             = 0                                   {product}
         intx G1ConcRefinementYellowZone                = 0                                   {product}
        uintx G1ConfidencePercent                       = 50                                  {product}
        uintx G1HeapRegionSize                          = 0                                   {product}
        uintx G1HeapWastePercent                        = 5                                   {product}
        uintx G1MixedGCCountTarget                      = 8                                   {product}
         intx G1RSetRegionEntries                       = 0                                   {product}
        uintx G1RSetScanBlockSize                       = 64                                  {product}
         intx G1RSetSparseRegionEntries                 = 0                                   {product}
         intx G1RSetUpdatingPauseTimePercent            = 10                                  {product}
         intx G1RefProcDrainInterval                    = 10                                  {product}
        uintx G1ReservePercent                          = 10                                  {product}
        uintx G1SATBBufferEnqueueingThresholdPercent    = 60                                  {product}
         intx G1SATBBufferSize                          = 1024                                {product}
         intx G1UpdateBufferSize                        = 256                                 {product}
         bool G1UseAdaptiveConcRefinement               = true                                {product}
        uintx GCDrainStackTargetSize                    = 64                                  {product}
        uintx GCHeapFreeLimit                           = 2                                   {product}
        uintx GCLockerEdenExpansionPercent              = 5                                   {product}
         bool GCLockerInvokesConcurrent                 = false                               {product}
        uintx GCLogFileSize                             = 8192                                {product}
        uintx GCPauseIntervalMillis                     = 0                                   {product}
        uintx GCTaskTimeStampEntries                    = 200                                 {product}
        uintx GCTimeLimit                               = 98                                  {product}
        uintx GCTimeRatio                               = 99                                  {product}
        uintx HeapBaseMinAddress                        = 2147483648                          {pd product}
         bool HeapDumpAfterFullGC                       = false                               {manageable}
         bool HeapDumpBeforeFullGC                      = false                               {manageable}
         bool HeapDumpOnOutOfMemoryError                = false                               {manageable}
        ccstr HeapDumpPath                              =                                     {manageable}
        uintx HeapFirstMaximumCompactionCount           = 3                                   {product}
        uintx HeapMaximumCompactionInterval             = 20                                  {product}
        uintx HeapSizePerGCThread                       = 67108864                            {product}
         bool IgnoreEmptyClassPaths                     = false                               {product}
         bool IgnoreUnrecognizedVMOptions               = false                               {product}
        uintx IncreaseFirstTierCompileThresholdAt       = 50                                  {product}
        uintx InitialBootClassLoaderMetaspaceSize       = 2252800                             {product}
        uintx InitialCodeCacheSize                      = 163840                              {pd product}
        uintx InitialHeapSize                          := 16777216                            {product}
        uintx InitialRAMFraction                        = 64                                  {product}
        uintx InitialSurvivorRatio                      = 8                                   {product}
        uintx InitialTenuringThreshold                  = 7                                   {product}
        uintx InitiatingHeapOccupancyPercent            = 45                                  {product}
         bool Inline                                    = true                                {product}
        ccstr InlineDataFile                            =                                     {product}
         intx InlineSmallCode                           = 1000                                {pd product}
         bool InlineSynchronizedMethods                 = true                                {C1 product}
         intx InterpreterProfilePercentage              = 33                                  {product}
         bool JNIDetachReleasesMonitors                 = true                                {product}
         bool JavaMonitorsInStackTrace                  = true                                {product}
         intx JavaPriority10_To_OSPriority              = -1                                  {product}
         intx JavaPriority1_To_OSPriority               = -1                                  {product}
         intx JavaPriority2_To_OSPriority               = -1                                  {product}
         intx JavaPriority3_To_OSPriority               = -1                                  {product}
         intx JavaPriority4_To_OSPriority               = -1                                  {product}
         intx JavaPriority5_To_OSPriority               = -1                                  {product}
         intx JavaPriority6_To_OSPriority               = -1                                  {product}
         intx JavaPriority7_To_OSPriority               = -1                                  {product}
         intx JavaPriority8_To_OSPriority               = -1                                  {product}
         intx JavaPriority9_To_OSPriority               = -1                                  {product}
         bool LIRFillDelaySlots                         = false                               {C1 pd product}
        uintx LargePageHeapSizeThreshold                = 134217728                           {product}
        uintx LargePageSizeInBytes                      = 0                                   {product}
         bool LazyBootClassLoader                       = true                                {product}
         bool LogCommercialFeatures                     = false                               {product}
         bool ManagementServer                          = false                               {product}
        uintx MarkStackSize                             = 32768                               {product}
        uintx MarkStackSizeMax                          = 4194304                             {product}
        uintx MarkSweepAlwaysCompactCount               = 4                                   {product}
        uintx MarkSweepDeadRatio                        = 5                                   {product}
         intx MaxBCEAEstimateLevel                      = 5                                   {product}
         intx MaxBCEAEstimateSize                       = 150                                 {product}
        uintx MaxDirectMemorySize                       = 0                                   {product}
         bool MaxFDLimit                                = true                                {product}
        uintx MaxGCMinorPauseMillis                     = 4294967295                          {product}
        uintx MaxGCPauseMillis                          = 4294967295                          {product}
        uintx MaxHeapFreeRatio                          = 70                                  {manageable}
        uintx MaxHeapSize                              := 268435456                           {product}
         intx MaxInlineLevel                            = 9                                   {product}
         intx MaxInlineSize                             = 35                                  {product}
         intx MaxJNILocalCapacity                       = 65536                               {product}
         intx MaxJavaStackTraceDepth                    = 1024                                {product}
        uintx MaxMetaspaceExpansion                     = 4194304                             {product}
        uintx MaxMetaspaceFreeRatio                     = 70                                  {product}
        uintx MaxMetaspaceSize                          = 4294901760                          {product}
        uintx MaxNewSize                               := 89456640                            {product}
     uint64_t MaxRAM                                    = 1073741824                          {pd product}
        uintx MaxRAMFraction                            = 4                                   {product}
         intx MaxRecursiveInlineLevel                   = 1                                   {product}
        uintx MaxTenuringThreshold                      = 15                                  {product}
         intx MaxTrivialSize                            = 6                                   {product}
        uintx MetaspaceSize                             = 12582912                            {pd product}
         bool MethodFlushing                            = true                                {product}
        uintx MinHeapDeltaBytes                        := 131072                              {product}
        uintx MinHeapFreeRatio                          = 40                                  {manageable}
         intx MinInliningThreshold                      = 250                                 {product}
        uintx MinMetaspaceExpansion                     = 262144                              {product}
        uintx MinMetaspaceFreeRatio                     = 40                                  {product}
        uintx MinRAMFraction                            = 2                                   {product}
        uintx MinSurvivorRatio                          = 3                                   {product}
        uintx MinTLABSize                               = 2048                                {product}
         intx MonitorBound                              = 0                                   {product}
         bool MonitorInUseLists                         = false                               {product}
         bool MustCallLoadClassInternal                 = false                               {product}
        uintx NUMAChunkResizeWeight                     = 20                                  {product}
        uintx NUMAInterleaveGranularity                 = 2097152                             {product}
        uintx NUMAPageScanRate                          = 256                                 {product}
        uintx NUMASpaceResizeRate                       = 1073741824                          {product}
         bool NUMAStats                                 = false                               {product}
        ccstr NativeMemoryTracking                      = off                                 {product}
         bool NeedsDeoptSuspend                         = false                               {pd product}
         bool NeverActAsServerClassMachine              = true                                {pd product}
         bool NeverTenure                               = false                               {product}
        uintx NewRatio                                  = 2                                   {product}
        uintx NewSize                                  := 5570560                             {product}
        uintx NewSizeThreadIncrease                     = 4096                                {pd product}
         intx NmethodSweepActivity                      = 10                                  {product}
         intx NmethodSweepCheckInterval                 = 5                                   {product}
         intx NmethodSweepFraction                      = 3                                   {product}
        uintx NumberOfGCLogFiles                        = 0                                   {product}
        uintx OldPLABSize                               = 1024                                {product}
        uintx OldPLABWeight                             = 50                                  {product}
        uintx OldSize                                  := 11206656                            {product}
         bool OmitStackTraceInFastThrow                 = true                                {product}
    ccstrlist OnError                                   =                                     {product}
    ccstrlist OnOutOfMemoryError                        =                                     {product}
         intx OnStackReplacePercentage                  = 933                                 {pd product}
         intx OptoLoopAlignment                         = 16                                  {pd product}
        uintx PLABWeight                                = 75                                  {product}
         bool PSChunkLargeArrays                        = true                                {product}
         intx ParGCArrayScanChunk                       = 50                                  {product}
        uintx ParGCDesiredObjsFromOverflowList          = 20                                  {product}
         bool ParGCTrimOverflow                         = true                                {product}
         bool ParGCUseLocalOverflow                     = false                               {product}
        uintx ParallelGCBufferWastePct                  = 10                                  {product}
        uintx ParallelGCThreads                         = 0                                   {product}
         bool ParallelGCVerbose                         = false                               {product}
        uintx ParallelOldDeadWoodLimiterMean            = 50                                  {product}
        uintx ParallelOldDeadWoodLimiterStdDev          = 80                                  {product}
         bool ParallelRefProcBalancingEnabled           = true                                {product}
         bool ParallelRefProcEnabled                    = false                               {product}
        uintx PausePadding                              = 1                                   {product}
         intx PerBytecodeRecompilationCutoff            = 200                                 {product}
         intx PerBytecodeTrapLimit                      = 4                                   {product}
         intx PerMethodRecompilationCutoff              = 400                                 {product}
         intx PerMethodTrapLimit                        = 100                                 {product}
         bool PerfAllowAtExitRegistration               = false                               {product}
         bool PerfBypassFileSystemCheck                 = false                               {product}
         intx PerfDataMemorySize                        = 32768                               {product}
         intx PerfDataSamplingInterval                  = 50                                  {product}
        ccstr PerfDataSaveFile                          =                                     {product}
         bool PerfDataSaveToFile                        = false                               {product}
         bool PerfDisableSharedMem                      = false                               {product}
         intx PerfMaxStringConstLength                  = 1024                                {product}
         intx PreInflateSpin                            = 10                                  {pd product}
         bool PreferInterpreterNativeStubs              = false                               {pd product}
         intx PrefetchCopyIntervalInBytes               = -1                                  {product}
         intx PrefetchFieldsAhead                       = -1                                  {product}
         intx PrefetchScanIntervalInBytes               = -1                                  {product}
         bool PreserveAllAnnotations                    = false                               {product}
         bool PreserveFramePointer                      = false                               {pd product}
        uintx PretenureSizeThreshold                    = 0                                   {product}
         bool PrintAdaptiveSizePolicy                   = false                               {product}
         bool PrintCMSInitiationStatistics              = false                               {product}
         intx PrintCMSStatistics                        = 0                                   {product}
         bool PrintClassHistogram                       = false                               {manageable}
         bool PrintClassHistogramAfterFullGC            = false                               {manageable}
         bool PrintClassHistogramBeforeFullGC           = false                               {manageable}
         bool PrintCodeCache                            = false                               {product}
         bool PrintCodeCacheOnCompilation               = false                               {product}
         bool PrintCommandLineFlags                     = false                               {product}
         bool PrintCompilation                          = false                               {product}
         bool PrintConcurrentLocks                      = false                               {manageable}
         intx PrintFLSCensus                            = 0                                   {product}
         intx PrintFLSStatistics                        = 0                                   {product}
         bool PrintFlagsFinal                          := true                                {product}
         bool PrintFlagsInitial                         = false                               {product}
         bool PrintGC                                   = false                               {manageable}
         bool PrintGCApplicationConcurrentTime          = false                               {product}
         bool PrintGCApplicationStoppedTime             = false                               {product}
         bool PrintGCCause                              = true                                {product}
         bool PrintGCDateStamps                         = false                               {manageable}
         bool PrintGCDetails                            = false                               {manageable}
         bool PrintGCID                                 = false                               {manageable}
         bool PrintGCTaskTimeStamps                     = false                               {product}
         bool PrintGCTimeStamps                         = false                               {manageable}
         bool PrintHeapAtGC                             = false                               {product rw}
         bool PrintHeapAtGCExtended                     = false                               {product rw}
         bool PrintHeapAtSIGBREAK                       = true                                {product}
         bool PrintJNIGCStalls                          = false                               {product}
         bool PrintJNIResolving                         = false                               {product}
         bool PrintOldPLAB                              = false                               {product}
         bool PrintOopAddress                           = false                               {product}
         bool PrintPLAB                                 = false                               {product}
         bool PrintParallelOldGCPhaseTimes              = false                               {product}
         bool PrintPromotionFailure                     = false                               {product}
         bool PrintReferenceGC                          = false                               {product}
         bool PrintSafepointStatistics                  = false                               {product}
         intx PrintSafepointStatisticsCount             = 300                                 {product}
         intx PrintSafepointStatisticsTimeout           = -1                                  {product}
         bool PrintSharedArchiveAndExit                 = false                               {product}
         bool PrintSharedDictionary                     = false                               {product}
         bool PrintSharedSpaces                         = false                               {product}
         bool PrintStringDeduplicationStatistics        = false                               {product}
         bool PrintStringTableStatistics                = false                               {product}
         bool PrintTLAB                                 = false                               {product}
         bool PrintTenuringDistribution                 = false                               {product}
         bool PrintTieredEvents                         = false                               {product}
         bool PrintVMOptions                            = false                               {product}
         bool PrintVMQWaitTime                          = false                               {product}
         bool PrintWarnings                             = true                                {product}
        uintx ProcessDistributionStride                 = 4                                   {product}
         bool ProfileInterpreter                        = false                               {pd product}
         bool ProfileIntervals                          = false                               {product}
         intx ProfileIntervalsTicks                     = 100                                 {product}
         intx ProfileMaturityPercentage                 = 20                                  {product}
         bool ProfileVM                                 = false                               {product}
         bool ProfilerPrintByteCodeStatistics           = false                               {product}
         bool ProfilerRecordPC                          = false                               {product}
        uintx PromotedPadding                           = 3                                   {product}
        uintx QueuedAllocationWarningCount              = 0                                   {product}
        uintx RTMRetryCount                             = 5                                   {ARCH product}
         bool RangeCheckElimination                     = true                                {product}
         intx ReadPrefetchInstr                         = 0                                   {ARCH product}
         bool ReduceSignalUsage                         = false                               {product}
         intx RefDiscoveryPolicy                        = 0                                   {product}
         bool ReflectionWrapResolutionErrors            = true                                {product}
         bool RegisterFinalizersAtInit                  = true                                {product}
         bool RelaxAccessControlCheck                   = false                               {product}
        ccstr ReplayDataFile                            =                                     {product}
         bool RequireSharedSpaces                       = false                               {product}
        uintx ReservedCodeCacheSize                     = 33554432                            {pd product}
         bool ResizeOldPLAB                             = true                                {product}
         bool ResizePLAB                                = true                                {product}
         bool ResizeTLAB                                = true                                {pd product}
         bool RestoreMXCSROnJNICalls                    = false                               {product}
         bool RestrictContended                         = true                                {product}
         bool RewriteBytecodes                          = false                               {pd product}
         bool RewriteFrequentPairs                      = false                               {pd product}
         intx SafepointPollOffset                       = 256                                 {C1 pd product}
         intx SafepointSpinBeforeYield                  = 2000                                {product}
         bool SafepointTimeout                          = false                               {product}
         intx SafepointTimeoutDelay                     = 10000                               {product}
         bool ScavengeBeforeFullGC                      = true                                {product}
         intx SelfDestructTimer                         = 0                                   {product}
        uintx SharedBaseAddress                         = 0                                   {product}
        ccstr SharedClassListFile                       =                                     {product}
        uintx SharedMiscCodeSize                        = 122880                              {product}
        uintx SharedMiscDataSize                        = 2097152                             {product}
        uintx SharedReadOnlySize                        = 12582912                            {product}
        uintx SharedReadWriteSize                       = 12582912                            {product}
         bool ShowMessageBoxOnError                     = false                               {product}
         intx SoftRefLRUPolicyMSPerMB                   = 1000                                {product}
         intx StackRedPages                             = 1                                   {pd product}
         intx StackShadowPages                          = 4                                   {pd product}
         bool StackTraceInThrowable                     = true                                {product}
         intx StackYellowPages                          = 3                                   {pd product}
         bool StartAttachListener                       = false                               {product}
         intx StarvationMonitorInterval                 = 200                                 {product}
         bool StressLdcRewrite                          = false                               {product}
        uintx StringDeduplicationAgeThreshold           = 3                                   {product}
        uintx StringTableSize                           = 1009                                {product}
         bool SuppressFatalErrorMessage                 = false                               {product}
        uintx SurvivorPadding                           = 3                                   {product}
        uintx SurvivorRatio                             = 8                                   {product}
         intx SuspendRetryCount                         = 50                                  {product}
         intx SuspendRetryDelay                         = 5                                   {product}
         intx SyncFlags                                 = 0                                   {product}
        ccstr SyncKnobs                                 =                                     {product}
         intx SyncVerbose                               = 0                                   {product}
        uintx TLABAllocationWeight                      = 35                                  {product}
        uintx TLABRefillWasteFraction                   = 64                                  {product}
        uintx TLABSize                                  = 0                                   {product}
         bool TLABStats                                 = true                                {product}
        uintx TLABWasteIncrement                        = 4                                   {product}
        uintx TLABWasteTargetPercent                    = 1                                   {product}
        uintx TargetPLABWastePct                        = 10                                  {product}
        uintx TargetSurvivorRatio                       = 50                                  {product}
        uintx TenuredGenerationSizeIncrement            = 20                                  {product}
        uintx TenuredGenerationSizeSupplement           = 80                                  {product}
        uintx TenuredGenerationSizeSupplementDecay      = 2                                   {product}
         intx ThreadPriorityPolicy                      = 0                                   {product}
         bool ThreadPriorityVerbose                     = false                               {product}
        uintx ThreadSafetyMargin                        = 52428800                            {product}
         intx ThreadStackSize                           = 0                                   {pd product}
        uintx ThresholdTolerance                        = 10                                  {product}
         intx Tier0BackedgeNotifyFreqLog                = 10                                  {product}
         intx Tier0InvokeNotifyFreqLog                  = 7                                   {product}
         intx Tier0ProfilingStartPercentage             = 200                                 {product}
         intx Tier23InlineeNotifyFreqLog                = 20                                  {product}
         intx Tier2BackEdgeThreshold                    = 0                                   {product}
         intx Tier2BackedgeNotifyFreqLog                = 14                                  {product}
         intx Tier2CompileThreshold                     = 0                                   {product}
         intx Tier2InvokeNotifyFreqLog                  = 11                                  {product}
         intx Tier3BackEdgeThreshold                    = 60000                               {product}
         intx Tier3BackedgeNotifyFreqLog                = 13                                  {product}
         intx Tier3CompileThreshold                     = 2000                                {product}
         intx Tier3DelayOff                             = 2                                   {product}
         intx Tier3DelayOn                              = 5                                   {product}
         intx Tier3InvocationThreshold                  = 200                                 {product}
         intx Tier3InvokeNotifyFreqLog                  = 10                                  {product}
         intx Tier3LoadFeedback                         = 5                                   {product}
         intx Tier3MinInvocationThreshold               = 100                                 {product}
         intx Tier4BackEdgeThreshold                    = 40000                               {product}
         intx Tier4CompileThreshold                     = 15000                               {product}
         intx Tier4InvocationThreshold                  = 5000                                {product}
         intx Tier4LoadFeedback                         = 3                                   {product}
         intx Tier4MinInvocationThreshold               = 600                                 {product}
         bool TieredCompilation                         = false                               {pd product}
         intx TieredCompileTaskTimeout                  = 50                                  {product}
         intx TieredRateUpdateMaxTime                   = 25                                  {product}
         intx TieredRateUpdateMinTime                   = 1                                   {product}
         intx TieredStopAtLevel                         = 4                                   {product}
         bool TimeLinearScan                            = false                               {C1 product}
         bool TraceBiasedLocking                        = false                               {product}
         bool TraceClassLoading                         = false                               {product rw}
         bool TraceClassLoadingPreorder                 = false                               {product}
         bool TraceClassPaths                           = false                               {product}
         bool TraceClassResolution                      = false                               {product}
         bool TraceClassUnloading                       = false                               {product rw}
         bool TraceDynamicGCThreads                     = false                               {product}
         bool TraceGen0Time                             = false                               {product}
         bool TraceGen1Time                             = false                               {product}
        ccstr TraceJVMTI                                =                                     {product}
         bool TraceLoaderConstraints                    = false                               {product rw}
         bool TraceMetadataHumongousAllocation          = false                               {product}
         bool TraceMonitorInflation                     = false                               {product}
         bool TraceParallelOldGCTasks                   = false                               {product}
         intx TraceRedefineClasses                      = 0                                   {product}
         bool TraceSafepointCleanupTime                 = false                               {product}
         bool TraceSharedLookupCache                    = false                               {product}
         bool TraceSuspendWaitFailures                  = false                               {product}
         bool TransmitErrorReport                       = false                               {product}
         bool TrapBasedNullChecks                       = false                               {pd product}
         intx TypeProfileArgsLimit                      = 2                                   {product}
        uintx TypeProfileLevel                          = 111                                 {pd product}
         intx TypeProfileParmsLimit                     = 2                                   {product}
         intx TypeProfileWidth                          = 2                                   {product}
         intx UnguardOnExecutionViolation               = 0                                   {product}
         bool UnlinkSymbolsALot                         = false                               {product}
         bool Use486InstrsOnly                          = false                               {ARCH product}
         bool UseAES                                    = true                                {product}
         bool UseAESIntrinsics                          = true                                {product}
         intx UseAVX                                    = 2                                   {ARCH product}
         bool UseAdaptiveGCBoundary                     = false                               {product}
         bool UseAdaptiveGenerationSizePolicyAtMajorCollection  = true                                {product}
         bool UseAdaptiveGenerationSizePolicyAtMinorCollection  = true                                {product}
         bool UseAdaptiveNUMAChunkSizing                = true                                {product}
         bool UseAdaptiveSizeDecayMajorGCCost           = true                                {product}
         bool UseAdaptiveSizePolicy                     = true                                {product}
         bool UseAdaptiveSizePolicyFootprintGoal        = true                                {product}
         bool UseAdaptiveSizePolicyWithSystemGC         = false                               {product}
         bool UseAddressNop                             = true                                {ARCH product}
         bool UseAltSigs                                = false                               {product}
         bool UseAutoGCSelectPolicy                     = false                               {product}
         bool UseBMI1Instructions                       = true                                {ARCH product}
         bool UseBMI2Instructions                       = true                                {ARCH product}
         bool UseBiasedLocking                          = true                                {product}
         bool UseBoundThreads                           = true                                {product}
         bool UseCLMUL                                  = true                                {ARCH product}
         bool UseCMSBestFit                             = true                                {product}
         bool UseCMSCollectionPassing                   = true                                {product}
         bool UseCMSCompactAtFullCollection             = true                                {product}
         bool UseCMSInitiatingOccupancyOnly             = false                               {product}
         bool UseCRC32Intrinsics                        = true                                {product}
         bool UseCodeCacheFlushing                      = true                                {product}
         bool UseCompiler                               = true                                {product}
         bool UseCompilerSafepoints                     = true                                {product}
         bool UseConcMarkSweepGC                        = false                               {product}
         bool UseCountLeadingZerosInstruction           = true                                {ARCH product}
         bool UseCountTrailingZerosInstruction          = true                                {ARCH product}
         bool UseCounterDecay                           = true                                {product}
         bool UseDynamicNumberOfGCThreads               = false                               {product}
         bool UseFastAccessorMethods                    = false                               {product}
         bool UseFastEmptyMethods                       = false                               {product}
         bool UseFastJNIAccessors                       = true                                {product}
         bool UseFastStosb                              = true                                {ARCH product}
         bool UseG1GC                                   = false                               {product}
         bool UseGCLogFileRotation                      = false                               {product}
         bool UseGCOverheadLimit                        = true                                {product}
         bool UseGCTaskAffinity                         = false                               {product}
         bool UseHeavyMonitors                          = false                               {product}
         bool UseInlineCaches                           = true                                {product}
         bool UseInterpreter                            = true                                {product}
         bool UseLWPSynchronization                     = true                                {product}
         bool UseLargePages                             = false                               {pd product}
         bool UseLargePagesInMetaspace                  = false                               {product}
         bool UseLargePagesIndividualAllocation        := false                               {pd product}
         bool UseLockedTracing                          = false                               {product}
         bool UseLoopCounter                            = true                                {product}
         bool UseLoopInvariantCodeMotion                = true                                {C1 product}
         bool UseMaximumCompactionOnSystemGC            = true                                {product}
         bool UseMembar                                 = false                               {pd product}
         bool UseNUMA                                   = false                               {product}
         bool UseNUMAInterleaving                       = false                               {product}
         bool UseNewLongLShift                          = false                               {ARCH product}
         bool UseOSErrorReporting                       = false                               {pd product}
         bool UseOnStackReplacement                     = true                                {pd product}
         bool UsePSAdaptiveSurvivorSizePolicy           = true                                {product}
         bool UseParNewGC                               = false                               {product}
         bool UseParallelGC                             = false                               {product}
         bool UseParallelOldGC                          = false                               {product}
         bool UsePerfData                               = true                                {product}
         bool UsePopCountInstruction                    = true                                {product}
         bool UseRTMDeopt                               = false                               {ARCH product}
         bool UseRTMLocking                             = false                               {ARCH product}
         bool UseSHA                                    = false                               {product}
         bool UseSHA1Intrinsics                         = false                               {product}
         bool UseSHA256Intrinsics                       = false                               {product}
         bool UseSHA512Intrinsics                       = false                               {product}
         intx UseSSE                                    = 4                                   {product}
         bool UseSSE42Intrinsics                        = true                                {product}
         bool UseSerialGC                               = false                               {product}
         bool UseSharedSpaces                           = false                               {product}
         bool UseSignalChaining                         = true                                {product}
         bool UseStoreImmI16                            = false                               {ARCH product}
         bool UseStringDeduplication                    = false                               {product}
         bool UseTLAB                                   = true                                {pd product}
         bool UseThreadPriorities                       = true                                {pd product}
         bool UseTypeProfile                            = true                                {product}
         bool UseUTCFileTimestamp                       = true                                {product}
         bool UseUnalignedLoadStores                    = true                                {ARCH product}
         bool UseVMInterruptibleIO                      = false                               {product}
         bool UseXMMForArrayCopy                        = true                                {product}
         bool UseXmmI2D                                 = false                               {ARCH product}
         bool UseXmmI2F                                 = false                               {ARCH product}
         bool UseXmmLoadAndClearUpper                   = true                                {ARCH product}
         bool UseXmmRegToRegMoveAll                     = true                                {ARCH product}
         bool VMThreadHintNoPreempt                     = false                               {product}
         intx VMThreadPriority                          = -1                                  {product}
         intx VMThreadStackSize                         = 0                                   {pd product}
         intx ValueMapInitialSize                       = 11                                  {C1 product}
         intx ValueMapMaxLoopSize                       = 8                                   {C1 product}
         bool VerifyMergedCPBytecodes                   = true                                {product}
         bool VerifySharedSpaces                        = false                               {product}
         intx WorkAroundNPTLTimedWaitHang               = 1                                   {product}
        uintx YoungGenerationSizeIncrement              = 20                                  {product}
        uintx YoungGenerationSizeSupplement             = 80                                  {product}
        uintx YoungGenerationSizeSupplementDecay        = 8                                   {product}
        uintx YoungPLABSize                             = 4096                                {product}
         bool ZeroTLAB                                  = false                               {product}
         intx hashCode                                  = 5                                   {product}
    null
  • 相关阅读:
    Python 列表浅拷贝与深拷贝
    Linux 基本命令-----常用操作分类
    硬盘的分区方式
    github中fork的使用
    大O记号
    python的__file__和__name__变量
    python生成器
    python装饰器
    re模块元字符
    python_数据类型_list
  • 原文地址:https://www.cnblogs.com/dabrk/p/12409555.html
Copyright © 2020-2023  润新知