• 想写一篇jvm的工具入门


    为什么要写一个jvm的工具入门呢,一是自己也不会,二是因为不会所以想学一下,还有就是这个确实很重要,对学习jvm有很多的用处,对定位问题有很大的便利,以前毕业那会我记得有个笔试,知道JAVA_HOME/bin目录的工具吗,例举下3个以上,并说说有什么用,可以怎么使用,,,,我只能说呵呵了,写代码哪里要注意这么多哈

    一、基础了解

    我们一般安装java,首先都会来一个java命令(现阶段java8和11用的人比较多,我这里还是8)

    D:Datalugh1>java
    用法: java [-options] class [args...]
               (执行类)
       或  java [-options] -jar jarfile [args...]
               (执行 jar 文件)
    其中选项包括:
        -d32          使用 32 位数据模型 (如果可用)
        -d64          使用 64 位数据模型 (如果可用)
        -server       选择 "server" VM
                      默认 VM 是 server.
    
        -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>
                      使用指定的图像显示启动屏幕

    参数分为三类,分别是:

    标准参数(很稳定的) 

    -help

     -version

    -X参数 (非标准参数,不能保证被所有的JVM实现都支持)

      -Xint

      -Xcomp

    -XX参数(使用率较高)

      -XX:newSize

      -XX:+UseSerialGC

    反正以前我是不知道-X,-XX,+UseSerialGC中的+号是什么,或许现在知道,好像也比较容易忘记,因为也没经常使用呀

    来试一下java -X

    D:Datalugh1>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
                          显示所有与区域设置相关的设置并继续

    -Xms<size> 设置初始 Java 堆大小
    -Xmx<size> 设置最大 Java 堆大小
    -Xss<size> 设置 Java 线程堆栈大小

    是不是觉得上面几个参数很熟悉,就是日常调整堆和栈大小的参数呀,很好记吧,比如java ‐Xms2048m ‐Xmx2048m  class_name

    在解释模式(interpreted mode)下,-Xint标记会强制JVM执行所有的字节码,当然这会降低运行速度,通常低10倍或更多

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

    接下来了解下-XX参数

    -XX参数的使用有2种方式,一种是boolean类型,一种是非boolean类型(好像有点废话)

    • boolean类型
    格式:-XX:[+-]
    如:-XX:+DisableExplicitGC 表示禁用手动调用gc操作,也就是说调用System.gc()无效,+表示启用,-表示禁止吧

    非boolean类型

    格式:-XX:
    如:-XX:NewRatio=1 表示新生代和老年代的比值

    那么多参数怎么记得呢,可以使用java -XX:+PrintFlagsFinal查看所有参数呀

    D:MyDatalugh1>java -XX:+PrintFlagsFinal
    [Global flags]
         intx ActiveProcessorCount                      = -1                                  {product}
        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 AggressiveHeap                            = false                               {product}
         bool AggressiveOpts                            = false                               {product}
         intx AliasLevel                                = 3                                   {C2 product}
         bool AlignVector                               = false                               {C2 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}
         intx AutoBoxCacheMax                           = 128                                 {C2 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 BlockLayoutByFrequency                    = true                                {C2 product}
         intx BlockLayoutMinDiamondPercentage           = 20                                  {C2 product}
         bool BlockLayoutRotateLoops                    = true                                {C2 product}
         bool BranchOnRegister                          = false                               {C2 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                        = true                                {C1 product}
         intx CICompilerCount                          := 3                                   {product}
         bool CICompilerCountPerCPU                     = true                                {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                    = 65536                               {pd product}
        uintx CodeCacheMinimumFreeSpace                 = 512000                              {product}
         bool CollectGen0First                          = false                               {product}
         bool CompactFields                             = true                                {product}
         intx CompilationPolicyChoice                   = 3                                   {product}
    ccstrlist CompileCommand                            =                                     {product}
        ccstr CompileCommandFile                        =                                     {product}
    ccstrlist CompileOnly                               =                                     {product}
         intx CompileThreshold                          = 10000                               {pd product}
         bool CompilerThreadHintNoPreempt               = true                                {product}
         intx CompilerThreadPriority                    = -1                                  {product}
         intx CompilerThreadStackSize                   = 0                                   {pd product}
        uintx CompressedClassSpaceSize                  = 1073741824                          {product}
        uintx ConcGCThreads                             = 0                                   {product}
         intx ConditionalMoveLimit                      = 3                                   {C2 pd product}
         intx ContendedPaddingWidth                     = 128                                 {product}
         bool ConvertSleepToYield                       = true                                {pd product}
         bool ConvertYieldToSleep                       = false                               {product}
         bool CrashOnOutOfMemoryError                   = 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 DoEscapeAnalysis                          = true                                {C2 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 EliminateAllocationArraySizeLimit         = 64                                  {C2 product}
         bool EliminateAllocations                      = true                                {C2 product}
         bool EliminateAutoBox                          = true                                {C2 product}
         bool EliminateLocks                            = true                                {C2 product}
         bool EliminateNestedLocks                      = true                                {C2 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}
       double EscapeAnalysisTimeout                     = 20.000000                           {C2 product}
         bool EstimateArgEscape                         = true                                {product}
         bool ExitOnOutOfMemoryError                    = false                               {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                       = 87241520                            {product}
         bool IgnoreEmptyClassPaths                     = false                               {product}
         bool IgnoreUnrecognizedVMOptions               = false                               {product}
        uintx IncreaseFirstTierCompileThresholdAt       = 50                                  {product}
         bool IncrementalInline                         = true                                {C2 product}
        uintx InitialBootClassLoaderMetaspaceSize       = 4194304                             {product}
        uintx InitialCodeCacheSize                      = 2555904                             {pd product}
        uintx InitialHeapSize                          := 132120576                           {product}
        uintx InitialRAMFraction                        = 64                                  {product}
       double InitialRAMPercentage                      = 1.562500                            {product}
        uintx InitialSurvivorRatio                      = 8                                   {product}
        uintx InitialTenuringThreshold                  = 7                                   {product}
        uintx InitiatingHeapOccupancyPercent            = 45                                  {product}
         bool Inline                                    = true                                {product}
        ccstr InlineDataFile                            =                                     {product}
         intx InlineSmallCode                           = 2000                                {pd product}
         bool InlineSynchronizedMethods                 = true                                {C1 product}
         bool InsertMemBarAfterArraycopy                = true                                {C2 product}
         intx InteriorEntryAlignment                    = 16                                  {C2 pd 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}
         intx LiveNodeCountInliningCutoff               = 40000                               {C2 product}
         bool LogCommercialFeatures                     = false                               {product}
         intx LoopMaxUnroll                             = 16                                  {C2 product}
         intx LoopOptsCount                             = 43                                  {C2 product}
         intx LoopUnrollLimit                           = 60                                  {C2 pd product}
         intx LoopUnrollMin                             = 4                                   {C2 product}
         bool LoopUnswitching                           = true                                {C2 product}
         bool ManagementServer                          = false                               {product}
        uintx MarkStackSize                             = 4194304                             {product}
        uintx MarkStackSizeMax                          = 536870912                           {product}
        uintx MarkSweepAlwaysCompactCount               = 4                                   {product}
        uintx MarkSweepDeadRatio                        = 1                                   {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                          = 100                                 {manageable}
        uintx MaxHeapSize                              := 2111832064                          {product}
         intx MaxInlineLevel                            = 9                                   {product}
         intx MaxInlineSize                             = 35                                  {product}
         intx MaxJNILocalCapacity                       = 65536                               {product}
         intx MaxJavaStackTraceDepth                    = 1024                                {product}
         intx MaxJumpTableSize                          = 65000                               {C2 product}
         intx MaxJumpTableSparseness                    = 5                                   {C2 product}
         intx MaxLabelRootDepth                         = 1100                                {C2 product}
         intx MaxLoopPad                                = 11                                  {C2 product}
        uintx MaxMetaspaceExpansion                     = 5451776                             {product}
        uintx MaxMetaspaceFreeRatio                     = 70                                  {product}
        uintx MaxMetaspaceSize                          = 4294901760                          {product}
        uintx MaxNewSize                               := 703594496                           {product}
         intx MaxNodeLimit                              = 75000                               {C2 product}
     uint64_t MaxRAM                                    = 0                                   {pd product}
        uintx MaxRAMFraction                            = 4                                   {product}
       double MaxRAMPercentage                          = 25.000000                           {product}
         intx MaxRecursiveInlineLevel                   = 1                                   {product}
        uintx MaxTenuringThreshold                      = 15                                  {product}
         intx MaxTrivialSize                            = 6                                   {product}
         intx MaxVectorSize                             = 32                                  {C2 product}
        uintx MetaspaceSize                             = 21807104                            {pd product}
         bool MethodFlushing                            = true                                {product}
        uintx MinHeapDeltaBytes                        := 524288                              {product}
        uintx MinHeapFreeRatio                          = 0                                   {manageable}
         intx MinInliningThreshold                      = 250                                 {product}
         intx MinJumpTableSize                          = 10                                  {C2 pd product}
        uintx MinMetaspaceExpansion                     = 339968                              {product}
        uintx MinMetaspaceFreeRatio                     = 40                                  {product}
        uintx MinRAMFraction                            = 2                                   {product}
       double MinRAMPercentage                          = 50.000000                           {product}
        uintx MinSurvivorRatio                          = 3                                   {product}
        uintx MinTLABSize                               = 2048                                {product}
         intx MonitorBound                              = 0                                   {product}
         bool MonitorInUseLists                         = false                               {product}
         intx MultiArrayExpandLimit                     = 6                                   {C2 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              = false                               {pd product}
         bool NeverTenure                               = false                               {product}
        uintx NewRatio                                  = 2                                   {product}
        uintx NewSize                                  := 44040192                            {product}
        uintx NewSizeThreadIncrease                     = 5320                                {pd product}
         intx NmethodSweepActivity                      = 10                                  {product}
         intx NmethodSweepCheckInterval                 = 5                                   {product}
         intx NmethodSweepFraction                      = 16                                  {product}
         intx NodeLimitFudgeFactor                      = 2000                                {C2 product}
        uintx NumberOfGCLogFiles                        = 0                                   {product}
         intx NumberOfLoopInstrToAlign                  = 4                                   {C2 product}
         intx ObjectAlignmentInBytes                    = 8                                   {lp64_product}
        uintx OldPLABSize                               = 1024                                {product}
        uintx OldPLABWeight                             = 50                                  {product}
        uintx OldSize                                  := 88080384                            {product}
         bool OmitStackTraceInFastThrow                 = true                                {product}
    ccstrlist OnError                                   =                                     {product}
    ccstrlist OnOutOfMemoryError                        =                                     {product}
         intx OnStackReplacePercentage                  = 140                                 {pd product}
         bool OptimizeFill                              = true                                {C2 product}
         bool OptimizePtrCompare                        = true                                {C2 product}
         bool OptimizeStringConcat                      = true                                {C2 product}
         bool OptoBundling                              = false                               {C2 pd product}
         intx OptoLoopAlignment                         = 16                                  {pd product}
         bool OptoScheduling                            = false                               {C2 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                         = 4                                   {product}
         bool ParallelGCVerbose                         = false                               {product}
        uintx ParallelOldDeadWoodLimiterMean            = 50                                  {product}
        uintx ParallelOldDeadWoodLimiterStdDev          = 80                                  {product}
         bool ParallelRefProcBalancingEnabled           = true                                {product}
         bool ParallelRefProcEnabled                    = false                               {product}
         bool PartialPeelAtUnsignedTests                = true                                {C2 product}
         bool PartialPeelLoop                           = true                                {C2 product}
         intx PartialPeelNewPhiDelta                    = 0                                   {C2 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               = 576                                 {product}
         intx PrefetchFieldsAhead                       = 1                                   {product}
         intx PrefetchScanIntervalInBytes               = 576                                 {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                        = true                                {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 ReassociateInvariants                     = true                                {C2 product}
         bool ReduceBulkZeroing                         = true                                {C2 product}
         bool ReduceFieldZeroing                        = true                                {C2 product}
         bool ReduceInitialCardMarks                    = true                                {C2 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                     = 251658240                           {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                          = true                                {pd product}
         bool RewriteFrequentPairs                      = true                                {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                        = 4194304                             {product}
        uintx SharedReadOnlySize                        = 16777216                            {product}
        uintx SharedReadWriteSize                       = 16777216                            {product}
         bool ShowMessageBoxOnError                     = false                               {product}
         intx SoftRefLRUPolicyMSPerMB                   = 1000                                {product}
         bool SpecialEncodeISOArray                     = true                                {C2 product}
         bool SplitIfBlocks                             = true                                {C2 product}
         intx StackRedPages                             = 1                                   {pd product}
         intx StackShadowPages                          = 6                                   {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                           = 60013                               {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                         = true                                {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}
         intx TrackedInitializationLimit                = 50                                  {C2 product}
         bool TransmitErrorReport                       = false                               {product}
         bool TrapBasedNullChecks                       = false                               {pd product}
         bool TrapBasedRangeChecks                      = false                               {C2 pd product}
         intx TypeProfileArgsLimit                      = 2                                   {product}
        uintx TypeProfileLevel                          = 111                                 {pd product}
         intx TypeProfileMajorReceiverPercent           = 90                                  {C2 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 UseBimorphicInlining                      = true                                {C2 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 UseCompressedClassPointers               := true                                {lp64_product}
         bool UseCompressedOops                        := true                                {lp64_product}
         bool UseConcMarkSweepGC                        = false                               {product}
         bool UseCondCardMark                           = false                               {C2 product}
         bool UseCountLeadingZerosInstruction           = true                                {ARCH product}
         bool UseCountTrailingZerosInstruction          = true                                {ARCH product}
         bool UseCountedLoopSafepoints                  = false                               {C2 product}
         bool UseCounterDecay                           = true                                {product}
         bool UseDivMod                                 = true                                {C2 product}
         bool UseDynamicNumberOfGCThreads               = false                               {product}
         bool UseFPUForSpilling                         = true                                {C2 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 UseJumpTables                             = true                                {C2 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 UseLoopPredicate                          = true                                {C2 product}
         bool UseMathExactIntrinsics                    = true                                {C2 product}
         bool UseMaximumCompactionOnSystemGC            = true                                {product}
         bool UseMembar                                 = false                               {pd product}
         bool UseMontgomeryMultiplyIntrinsic            = true                                {C2 product}
         bool UseMontgomerySquareIntrinsic              = true                                {C2 product}
         bool UseMulAddIntrinsic                        = true                                {C2 product}
         bool UseMultiplyToLenIntrinsic                 = true                                {C2 product}
         bool UseNUMA                                   = false                               {product}
         bool UseNUMAInterleaving                       = false                               {product}
         bool UseNewLongLShift                          = false                               {ARCH product}
         bool UseOSErrorReporting                       = false                               {pd product}
         bool UseOldInlining                            = true                                {C2 product}
         bool UseOnStackReplacement                     = true                                {pd product}
         bool UseOnlyInlinedBimorphic                   = true                                {C2 product}
         bool UseOptoBiasInlining                       = true                                {C2 product}
         bool UsePSAdaptiveSurvivorSizePolicy           = true                                {product}
         bool UseParNewGC                               = false                               {product}
         bool UseParallelGC                            := true                                {product}
         bool UseParallelOldGC                          = true                                {product}
         bool UsePerfData                               = true                                {product}
         bool UsePopCountInstruction                    = true                                {product}
         bool UseRDPCForConstantTableBase               = false                               {C2 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 UseSquareToLenIntrinsic                   = true                                {C2 product}
         bool UseStoreImmI16                            = false                               {ARCH product}
         bool UseStringDeduplication                    = false                               {product}
         bool UseSuperWord                              = true                                {C2 product}
         bool UseTLAB                                   = true                                {pd product}
         bool UseThreadPriorities                       = true                                {pd product}
         bool UseTypeProfile                            = true                                {product}
         bool UseTypeSpeculation                        = true                                {C2 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}
         intx ValueSearchLimit                          = 1000                                {C2 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}
    用法: java [-options] class [args...]
               (执行类)
       或  java [-options] -jar jarfile [args...]
               (执行 jar 文件)
    其中选项包括:
        -d32          使用 32 位数据模型 (如果可用)
        -d64          使用 64 位数据模型 (如果可用)
        -server       选择 "server" VM
                      默认 VM 是 server.
    
        -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>
                      使用指定的图像显示启动屏幕
    有关详细信息, 请参阅 http://www.oracle.com/technetwork/java/javase/documentation/index.html。
    View Code

    上面的参数中有等号(=和:=),分别代表的是默认值,和被修改的值啦

    好了,基础够基础了吧,以后这些加(+)减(-)等于(=或:=)看的懂了

    二、基础工具

    $JAVA_HOME/bin目录下真的有很多的工具,这里不截图啦,直接上用的比较的工具好啦

    2.1、jps

    这个工具真的很实用,而且很简单呢,功能linux的ps命令类似:可以列出正在运行的虚拟机进程,并显示虚拟机执行主类(Main Class,main()函数所在的类)名称以及这些进程的本地虚拟机唯一ID(LVMID,Local Virtual Machine Identifier)

    [root@hadoop apache-tomcat-8.5.57]# jps -help
    usage: jps [-help]
           jps [-q] [-mlvV] [<hostid>]
    
    Definitions:
        <hostid>:      <hostname>[:<port>]
    -l : 输出主类全名或jar路径
    -q : 只输出LVMID
    -m : 输出JVM启动时传递给main()的参数
    -v : 输出JVM启动时显示指定的JVM参数

     2.2、jstat

    jstat(JVM Statistics Monitoring Tool)是用于监视虚拟机各种运行状态信息的命令行工具。它可以显示本地或者远程[插图]虚拟机进程中的类加载、内存、垃圾收集、即时编译等运行时数据。

    [root@hadoop apache-tomcat-8.5.57]# jstat -help
    Usage: jstat -help|-options
           jstat -<option> [-t] [-h<lines>] <vmid> [<interval> [<count>]]
    
    Definitions:
      <option>      An option reported by the -options option
      <vmid>        Virtual Machine Identifier. A vmid takes the following form:
                         <lvmid>[@<hostname>[:<port>]]
                    Where <lvmid> is the local vm identifier for the target
                    Java virtual machine, typically a process id; <hostname> is
                    the name of the host running the target Java virtual machine;
                    and <port> is the port number for the rmiregistry on the
                    target host. See the jvmstat documentation for a more complete
                    description of the Virtual Machine Identifier.
      <lines>       Number of samples between header lines.
      <interval>    Sampling interval. The following forms are allowed:
                        <n>["ms"|"s"]
                    Where <n> is an integer and the suffix specifies the units as
                    milliseconds("ms") or seconds("s"). The default units are "ms".
      <count>       Number of samples to take before terminating.
      -J<flag>      Pass <flag> directly to the runtime system.

    jstat -options #查看下支持的选项,如下

    [root@hadoop apache-tomcat-8.5.57]# jstat -options
    -class  #类加载器
    -compiler #JIT
    -gc  #GC堆状态
    -gccapacity #各个区的大小
    -gccause #最近一次GC的统计和原因
    -gcmetacapacity #元空间大小
    -gcnew #新区统计
    -gcnewcapacity #新区大小
    -gcold #老区统计
    -gcoldcapacity #老区大小
    -gcutil #GC汇总统计
    -printcompilation #HotSpot编译统计
    Options #选项,我们一般使用 -gcutil 查看gc情况 
    vmid    #VM的进程号,即当前运行的java进程号,可以理解我java程序的pid
    interval #间隔时间,单位为秒或者毫秒
    count   #打印次数,如果缺省则打印无数次

    对于命令格式中的VMID与LVMID需要特别说明一下:如果是本地虚拟机进程,VMID与LVMID是一致的;如果是远程虚拟机进程,那VMID的格式应当是

    [protocol:][//]lvmid[@hostname][:port]/servername]

    开始操作:

    jstat -class 1645  #类加载的统计

    Loaded:加载class的数量
    Bytes:所占用空间大小
    Unloaded:未加载数量
    Bytes:未加载占用空间
    Time:时间

    jstat -gc 1645  1 3 #统计3次,每隔一秒,对gc进行统计

    S0C:第一个Survivor区的大小(KB)
    S1C:第二个Survivor区的大小(KB)
    S0U:第一个Survivor区的使用大小(KB)
    S1U:第二个Survivor区的使用大小(KB)
    EC:Eden区的大小(KB)
    EU:Eden区的使用大小(KB)
    OC:Old区大小(KB)
    OU:Old使用大小(KB)
    MC:方法区大小(KB),java8方法区的实现是元数据空间,java7的方法区实现是永久代
    MU:方法区使用大小(KB)
    CCSC:压缩类空间大小(KB)
    CCSU:压缩类空间使用大小(KB)
    YGC:年轻代垃圾回收次数
    YGCT:年轻代垃圾回收消耗时间
    FGC:老年代垃圾回收次数
    FGCT:老年代垃圾回收消耗时间
    GCT:垃圾回收消耗总时间

    jstat -compiler 1645 #对编译进行统计

    Compiled:编译数量。
    Failed:失败数量
    Invalid:不可用数量
    Time:时间
    FailedType:失败类型
    FailedMethod:失败的方法

     2.3、jinfo

    jinfo(Configuration Info for Java)的作用是实时查看和调整虚拟机各项参数

    [root@hadoop ~]# jinfo -help
    Usage:
        jinfo [option] <pid>
            (to connect to running process)
        jinfo [option] <executable <core>
            (to connect to a core file)
        jinfo [option] [server_id@]<remote server IP or hostname>
            (to connect to remote debug server)
    
    where <option> is one of:
        -flag <name>         to print the value of the named VM flag #打印单个jvm的参数
        -flag [+|-]<name>    to enable or disable the named VM flag #运行期修改一部分运行期可写的虚拟机参数值
        -flag <name>=<value> to set the named VM flag to the given value #运行期修改一部分运行期可写的虚拟机参数值
        -flags               to print VM flags #打印该进程的相关的参数
        -sysprops            to print Java system properties #把虚拟机进程的System.getProperties()的内容打印出来
        <no option>          to print both of the above
        -h | -help           to print this help message

    jinfo -flags  1645

     jinfo -flag InitialHeapSize  1645

     jinfo -flag InitialHeapSize  1645

    [root@hadoop ~]# jinfo -sysprops  1645
    Attaching to process ID 1645, please wait...
    Debugger attached successfully.
    Server compiler detected.
    JVM version is 25.181-b13
    java.runtime.name = Java(TM) SE Runtime Environment
    java.vm.version = 25.181-b13
    sun.boot.library.path = /home/hadoop/jdk/jre/lib/amd64
    java.protocol.handler.pkgs = org.apache.catalina.webresources
    shared.loader =
    java.vendor.url = http://java.oracle.com/
    java.vm.vendor = Oracle Corporation
    path.separator = :
    file.encoding.pkg = sun.io
    java.vm.name = Java HotSpot(TM) 64-Bit Server VM
    java.util.logging.config.file = /root/apache-tomcat-8.5.57/conf/logging.properties
    tomcat.util.buf.StringCache.byte.enabled = true
    sun.os.patch.level = unknown
    sun.java.launcher = SUN_STANDARD
    user.country = US
    tomcat.util.scan.StandardJarScanFilter.jarsToScan = log4j-taglib*.jar,log4j-web*.jar,log4javascript*.jar,slf4j-taglib*.jar
    user.dir = /root/apache-tomcat-8.5.57
    java.vm.specification.name = Java Virtual Machine Specification
    java.runtime.version = 1.8.0_181-b13
    java.awt.graphicsenv = sun.awt.X11GraphicsEnvironment
    os.arch = amd64
    java.endorsed.dirs = /home/hadoop/jdk/jre/lib/endorsed
    line.separator =
    
    java.io.tmpdir = /root/apache-tomcat-8.5.57/temp
    java.vm.specification.vendor = Oracle Corporation
    java.util.logging.manager = org.apache.juli.ClassLoaderLogManager
    java.naming.factory.url.pkgs = org.apache.naming
    os.name = Linux
    org.apache.catalina.security.SecurityListener.UMASK = 0027
    sun.jnu.encoding = UTF-8
    ignore.endorsed.dirs =
    java.library.path = /usr/java/packages/lib/amd64:/usr/lib64:/lib64:/lib:/usr/lib
    java.class.version = 52.0
    java.specification.name = Java Platform API Specification
    sun.management.compiler = HotSpot 64-Bit Tiered Compilers
    os.version = 2.6.32-754.24.3.el6.x86_64
    java.util.concurrent.ForkJoinPool.common.threadFactory = org.apache.catalina.startup.SafeForkJoinWorkerThreadFactory
    user.home = /root
    user.timezone = Asia/Chongqing
    catalina.useNaming = true
    java.awt.printerjob = sun.print.PSPrinterJob
    file.encoding = UTF-8
    java.specification.version = 1.8
    tomcat.util.scan.StandardJarScanFilter.jarsToSkip = annotations-api.jar,ant-junit*.jar,ant-launcher.jar,ant.jar,asm-*.jar,aspectj*.jar,bootstrap.jar,catalina-ant.jar,catalina-ha.jar,catalina-jmx-remote.jar,catalina-storeconfig.jar,catalina-tribes.jar,catalina-ws.jar,catalina.jar,cglib-*.jar,cobertura-*.jar,commons-beanutils*.jar,commons-codec*.jar,commons-collections*.jar,commons-daemon.jar,commons-dbcp*.jar,commons-digester*.jar,commons-fileupload*.jar,commons-httpclient*.jar,commons-io*.jar,commons-lang*.jar,commons-logging*.jar,commons-math*.jar,commons-pool*.jar,dom4j-*.jar,easymock-*.jar,ecj-*.jar,el-api.jar,geronimo-spec-jaxrpc*.jar,h2*.jar,hamcrest-*.jar,hibernate*.jar,httpclient*.jar,icu4j-*.jar,jasper-el.jar,jasper.jar,jaspic-api.jar,jaxb-*.jar,jaxen-*.jar,jdom-*.jar,jetty-*.jar,jmx-tools.jar,jmx.jar,jsp-api.jar,jstl.jar,jta*.jar,junit-*.jar,junit.jar,log4j*.jar,mail*.jar,objenesis-*.jar,oraclepki.jar,oro-*.jar,servlet-api-*.jar,servlet-api.jar,slf4j*.jar,taglibs-standard-spec-*.jar,tagsoup-*.jar,tomcat-api.jar,tomcat-coyote.jar,tomcat-dbcp.jar,tomcat-i18n-*.jar,tomcat-jdbc.jar,tomcat-jni.jar,tomcat-juli-adapters.jar,tomcat-juli.jar,tomcat-util-scan.jar,tomcat-util.jar,tomcat-websocket.jar,tools.jar,websocket-api.jar,wsdl4j*.jar,xercesImpl.jar,xml-apis.jar,xmlParserAPIs-*.jar,xmlParserAPIs.jar,xom-*.jar
    catalina.home = /root/apache-tomcat-8.5.57
    user.name = root
    java.class.path = /root/apache-tomcat-8.5.57/bin/bootstrap.jar:/root/apache-tomcat-8.5.57/bin/tomcat-juli.jar
    java.naming.factory.initial = org.apache.naming.java.javaURLContextFactory
    package.definition = sun.,java.,org.apache.catalina.,org.apache.coyote.,org.apache.jasper.,org.apache.naming.,org.apache.tomcat.
    java.vm.specification.version = 1.8
    sun.arch.data.model = 64
    sun.java.command = org.apache.catalina.startup.Bootstrap start
    java.home = /home/hadoop/jdk/jre
    user.language = en
    java.specification.vendor = Oracle Corporation
    awt.toolkit = sun.awt.X11.XToolkit
    java.vm.info = mixed mode
    java.version = 1.8.0_181
    java.ext.dirs = /home/hadoop/jdk/jre/lib/ext:/usr/java/packages/lib/ext
    sun.boot.class.path = /home/hadoop/jdk/jre/lib/resources.jar:/home/hadoop/jdk/jre/lib/rt.jar:/home/hadoop/jdk/jre/lib/sunrsasign.jar:/home/hadoop/jdk/jre/lib/jsse.jar:/home/hadoop/jdk/jre/lib/jce.jar:/home/hadoop/jdk/jre/lib/charsets.jar:/home/hadoop/jdk/jre/lib/jfr.jar:/home/hadoop/jdk/jre/classes
    server.loader =
    java.vendor = Oracle Corporation
    catalina.base = /root/apache-tomcat-8.5.57
    jdk.tls.ephemeralDHKeySize = 2048
    file.separator = /
    java.vendor.url.bug = http://bugreport.sun.com/bugreport/
    common.loader = "${catalina.base}/lib","${catalina.base}/lib/*.jar","${catalina.home}/lib","${catalina.home}/lib/*.jar"
    sun.io.unicode.encoding = UnicodeLittle
    sun.cpu.endian = little
    package.access = sun.,org.apache.catalina.,org.apache.coyote.,org.apache.jasper.,org.apache.tomcat.
    sun.cpu.isalist =
    View Code

    2.4、jmap

    jmap(Memory Map for Java)命令用于生成堆转储快照(一般称为heapdump或dump文件),还可以使用“暴力”方式:-XX:+HeapDumpOnOutOfMemoryError参数,可以让虚拟机在内存溢出异常出现之后自动生成堆转储快照文件

    jmap的作用并不仅仅是为了获取堆转储快照,它还可以查询finalize执行队列、Java堆和方法区的详细信息,如空间使用率、当前用的是哪种收集器等

    [root@hadoop ~]# jmap -help
    Usage:
        jmap [option] <pid>
            (to connect to running process)
        jmap [option] <executable <core>
            (to connect to a core file)
        jmap [option] [server_id@]<remote server IP or hostname>
            (to connect to remote debug server)
    
    where <option> is one of:
        <none>               to print same info as Solaris pmap
        -heap                to print java heap summary #统计堆
        -histo[:live]        to print histogram of java object heap; if the "live"
                             suboption is specified, only count live objects
        -clstats             to print class loader statistics
        -finalizerinfo       to print information on objects awaiting finalization
        -dump:<dump-options> to dump java heap in hprof binary format #dump出java堆的二进制文件
                             dump-options:
                               live         dump only live objects; if not specified,
                                            all objects in the heap are dumped.
                               format=b     binary format
                               file=<file>  dump heap to <file>
                             Example: jmap -dump:live,format=b,file=heap.bin <pid>
        -F                   force. Use with -dump:<dump-options> <pid> or -histo
                             to force a heap dump or histogram when <pid> does not
                             respond. The "live" suboption is not supported
                             in this mode.
        -h | -help           to print this help message
        -J<flag>             to pass <flag> directly to the runtime system
    -heap #打印jvm heap的情况,比如参数,分代,回收器等
    -histo #打印jvm heap的直方图。其输出信息包括类名,对象数量,对象占用大小。  
    -histo:live #同上,但是只答应存活对象的情况   
    -dump #生成堆转储快照,格式为-dump:[live,]format=b,file=<filename>,其中自参数说明是否只dump出存活对象
    -finalizerinfo #显示在F-Queue中等待的finalizer线程执行finalize方法的对象 
    -clstats #打印类的加载信息
    -F #强制生成dump文件

    jmap -heap 1645

     jmap -histo 1645 | more   #查看内存中的对象和数量

     上图中的对象说明:

    B byte
    C char
    D double
    F float
    I int
    J long
    Z boolean
    [ 数组,如[I表示int[]
    [L+类名 其他对象
    jmap -dump:format=b,file=/root/dump.bin 1645  #将内存的使用情况dump到文件中
    [root@hadoop bin]# jmap -dump:format=b,file=/root/dump.bin 1645
    Dumping heap to /root/dump.bin ...
    Heap dump file created

     2.5、jhat

    JDK提供jhat(JVM Heap Analysis Tool)命令与jmap搭配使用,来分析jmap生成的堆转储快照。jhat内置了一个微型的HTTP/Web服务器,生成堆转储快照的分析结果后,可以在浏览器中查看(实际情况使用的不多)

    [root@hadoop ~]# jhat -help
    Usage:  jhat [-stack <bool>] [-refs <bool>] [-port <port>] [-baseline <file>] [-debug <int>] [-version] [-h|-help] <file>
    
            -J<flag>          Pass <flag> directly to the runtime system. For
                              example, -J-mx512m to use a maximum heap size of 512MB
            -stack false:     Turn off tracking object allocation call stack.
            -refs false:      Turn off tracking of references to objects
            -port <port>:     Set the port for the HTTP server.  Defaults to 7000
            -exclude <file>:  Specify a file that lists data members that should
                              be excluded from the reachableFrom query.
            -baseline <file>: Specify a baseline object dump.  Objects in
                              both heap dumps with the same ID and same class will
                              be marked as not being "new".
            -debug <int>:     Set debug level.
                                0:  No debug output
                                1:  Debug hprof file parsing
                                2:  Debug hprof file parsing, no server
            -version          Report version number
            -h|-help          Print this help and exit
            <file>            The file to read
    
    For a dump file that contains multiple heap dumps,
    you may specify which dump in the file
    by appending "#<number>" to the file name, i.e. "foo.hprof#3".
    
    All boolean options default to "true"

    jhat -port 9999 dump.bin 

     登录自己的地址:http://192.168.88.137:9999/

     这个网址拉到最下面有一个查询功能:

     

     如上的每一个结果都可以点进去去查看

    2.6、jstack

    jstack(Stack Trace for Java)命令用于生成虚拟机当前时刻的线程快照(一般称为threaddump或者javacore文件)。线程快照就是当前虚拟机内每一条线程正在执行的方法堆栈的集合,生成线程快照的目的通常是定位线程出现长时间停顿的原因,如线程间死锁、死循环、请求外部资源导致的长时间挂起等,都是导致线程长时间停顿的常见原因

    [root@hadoop ~]# jstack -help
    Usage:
        jstack [-l] <pid>
            (to connect to running process)
        jstack -F [-m] [-l] <pid>
            (to connect to a hung process)
        jstack [-m] [-l] <executable> <core>
            (to connect to a core file)
        jstack [-m] [-l] [server_id@]<remote server IP or hostname>
            (to connect to a remote debug server)
    
    Options:
        -F  to force a thread dump. Use when jstack <pid> does not respond (process is hung)
        -m  to print both java and native frames (mixed mode)
        -l  long listing. Prints additional information about locks
        -h or -help to print this help message
    -F : 当正常输出请求不被响应时,强制输出线程堆栈
    -l : 除堆栈外,显示关于锁的附加信息
    -m : 如果调用到本地方法的话,可以显示C/C++的堆栈

    jstack 1645 | more  #查看该线程的快照信息

     如上的状态信息可以参考:java多线程与并发(基础篇)

    三、可视化工具

    3.1、JConsole

    JConsole(Java Monitoring and Management Console)是一款基于JMX(Java Manage-ment Extensions)的可视化监视、管理工具。它的主要功能是通过JMX的MBean(Managed Bean)对系统进行信息收集和参数动态调整

    一、本地连接

     可以看出来可以对内存,线程等进行监控。

    二、远程监控

    这里我们使用tomcat做实验,首先要修改catalina.sh文件,添加如下内容:参考https://blog.csdn.net/shamoshuizu/article/details/70598268

    JAVA_OPTS="-Djava.rmi.server.hostname=192.168.88.137 -Dcom.sun.management.jmxremote.port=8099 -Dcom.sun.management.jmxremote.rmi.port=8099 -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false"

    然后重启tomcat,接下来连接远程

    这个工具使用起来并不难,只要自己要有jvm的基础啦,不然看不懂,展示出来了也是白干活。

    3.2、VisualVM

    VisualVM(All-in-One Java Troubleshooting Tool)是功能最强大的运行监视和故障处理程序之一,能够监控线程,内存情况,查看方法的CPU时间和内存中的对象,已被GC的对象,反向查看分配的堆栈,使用起来也很简单

     双击jvisualvm.exe软件,打开该工具

    同JConsole 一样可以本地和远程,直接打开本地进程

     基本pid,jvm参数,主机等一览无余,还有监控页面包括cpu,堆,类,线程等监控,还可以执行垃圾回收,和dump线程呢

     试试远程的,同JConsole 的设置方式对tomcate进行设置

    其实工具是什么呢,就是为了方便获取信息嘛,能不能看懂,能不能还得看自己的水平够不够,能不能够发现问题,能不能解决问题了。

     3.3、JMC

     Java Mission Control:可持续在线的监控工具

    JMC与虚拟机之间同样采取JMX协议进行通信,JMC一方面作为JMX控制台,显示来自虚拟机MBean提供的数据;另一方面作为JFR的分析工具,展示来自JFR的数据

     用起来也很简单,双击jmc.exe打开工具,默认情况下会扫描出本地的进程,然后可以点击:文件->连接,来创建新的连接:

    然后根据下图操作,遇到情况下一步,下一步就好,就有如下的图了:

     该工具持续监控了很多东西:

    一般信息:关于虚拟机、操作系统和记录的一般信息。
    内存:关于内存管理和垃圾收集的信息。
    代码:关于方法、异常错误、编译和类加载的信息。
    线程:关于应用程序中线程和锁的信息。
    I/O:关于文件和套接字输入、输出的信息。
    系统:关于正在运行Java虚拟机的系统、进程和环境变量的信息。
    事件:关于记录中的事件类型的信息,可以根据线程或堆栈跟踪,按照日志或图形的格式查看。

    四、其他工具-MAT

    MAT(Memory Analyzer Tool),一个基于Eclipse的内存分析工具,是一个快速、功能丰富的JAVA heap分析工具,它可以帮助我们查找内存泄漏和减少内存消耗。使用内存分析工具从众多的对象中进行分析,快速的计算出在内存中对象的占用大小,看看是谁阻止了垃圾收集器的回收工作,并可以通过报表直观的查看到可能造成这种结果的对象

    官网:https://www.eclipse.org/mat/

    下载地址:https://www.eclipse.org/mat/downloads.php

    下载后,解压,双击MemoryAnalyzer.exe打开程序,然后点击文件->打开dump出的文件,就出现了如下的图

     下图可以看到基本的内存可能出问题的地方:

     

    这篇文章纯粹是一个工具的使用简单说明,没有太多的技术含量,但是我觉得工欲善其事必先利其器,所以用好一些工具对自己能力的提升,效率的提升有莫大的帮助,工具这些东西只有用到的时候才会查找,但是也要大概了解下怎么用吧,比如什么工具可以用来干嘛呢,我写这个的目的就是用来以后自己当做工具文档来查看下,技术用时方恨少,所以平时多积累些也不是一件坏事呢,好吧,好好努力撒。

  • 相关阅读:
    课程设计第八天,8.26
    课程设计第七天,08.25
    赖世雄英语
    英语语法-小学
    CSS(Cascading Style Sheet)
    Coredraw x7
    Servlet
    团队作业4——第一次项目冲刺(Alpha版本)2017.11.18
    团队作业4——第一次项目冲刺(Alpha版本)2017.11.16
    团队作业4——第一次项目冲刺(Alpha版本)2017.11.14
  • 原文地址:https://www.cnblogs.com/zsql/p/13669304.html
Copyright © 2020-2023  润新知