JVM 菜鸟进阶高手之路九（解惑）
关于MAT工具相关知识解惑
jmap -dump:format=b,file=heap.bin pid后面讲堆信息下载本地，经过MAT打开便可，第一个问题来了，我经过jmap相关命令获得的信息与MAT观察的信息不一致问题。
有没有以为很奇怪，明明4G的堆，dump文件也是4G多，为何用MAT打开就220M左右？？？？？ 奇怪吧，我也疑惑很久，由于由于MAT把不可达对象没加在里面，若是须要显示在MAT工具进行选择设置便可，以下：关于第八篇Xmn问题
time ls
Real, User and Sys process time statisticsphp
One of these things is not like the other. Real refers to actual elapsed time; User and Sys refer to CPU time used only by the process.html
Real is wall clock time - time from start to finish of the call. This is all elapsed time including time slices used by other processes and time the process spends blocked (for example if it is waiting for I/O to complete).java
User is the amount of CPU time spent in user-mode code (outside the kernel) within the process. This is only actual CPU time used in executing the process. Other processes and time the process spends blocked do not count towards this figure.linux
Sys is the amount of CPU time spent in the kernel within the process. This means executing CPU time spent in system calls within the kernel, as opposed to library code, which is still running in user-space. Like 'user', this is only CPU time used by the process. See below for a brief description of kernel mode (also known as 'supervisor' mode) and the system call mechanism.git
User+Sys will tell you how much actual CPU time your process used. Note that this is across all CPUs, so if the process has multiple threads (and this process is running on a computer with more than one processor) it could potentially exceed the wall clock time reported by Real (which usually occurs). Note that in the output these figures include the User and Sys time of all child processes (and their descendants) as well when they could have been collected, e.g. by wait(2) or waitpid(2), although the underlying system calls return the statistics for the process and its children separately.github
Origins of the statistics reported by time (1)算法
The statistics reported by time are gathered from various system calls. 'User' and 'Sys' come from wait (2) or times (2), depending on the particular system. 'Real' is calculated from a start and end time gathered from the gettimeofday (2) call. Depending on the version of the system, various other statistics such as the number of context switches may also be gathered by time.oracle
On a multi-processor machine, a multi-threaded process or a process forking children could have an elapsed time smaller than the total CPU time - as different threads or processes may run in parallel. Also, the time statistics reported come from different origins, so times recorded for very short running tasks may be subject to rounding errors, as the example given by the original poster shows.app
A brief primer on Kernel vs. User modeless
On Unix, or any protected-memory operating system, 'Kernel' or 'Supervisor' mode refers to a privileged mode that the CPU can operate in. Certain privileged actions that could affect security or stability can only be done when the CPU is operating in this mode; these actions are not available to application code. An example of such an action might be manipulation of the MMU to gain access to the address space of another process. Normally, user-mode code cannot do this (with good reason), although it can request shared memory from the kernel, which could be read or written by more than one process. In this case, the shared memory is explicitly requested from the kernel through a secure mechanism and both processes have to explicitly attach to it in order to use it.
The privileged mode is usually referred to as 'kernel' mode because the kernel is executed by the CPU running in this mode. In order to switch to kernel mode you have to issue a specific instruction (often called a trap) that switches the CPU to running in kernel mode and runs code from a specific location held in a jump table. For security reasons, you cannot switch to kernel mode and execute arbitrary code - the traps are managed through a table of addresses that cannot be written to unless the CPU is running in supervisor mode. You trap with an explicit trap number and the address is looked up in the jump table; the kernel has a finite number of controlled entry points.
The 'system' calls in the C library (particularly those described in Section 2 of the man pages) have a user-mode component, which is what you actually call from your C program. Behind the scenes, they may issue one or more system calls to the kernel to do specific services such as I/O, but they still also have code running in user-mode. It is also quite possible to directly issue a trap to kernel mode from any user space code if desired, although you may need to write a snippet of assembly language to set up the registers correctly for the call. A page describing the system calls provided by the Linux kernel and the conventions for setting up registers can be found here.
More about 'sys'
There are things that your code cannot do from user mode - things like allocating memory or accessing hardware (HDD, network, etc.). These are under the supervision of the kernel, and it alone can do them. Some operations that you do (like malloc orfread/fwrite) will invoke these Kernel functions and that then will count as 'sys' time. Unfortunately it's not as simple as "every call to malloc will be counted in 'sys' time". The call to malloc will do some processing of its own (still counted in 'user' time) and then somewhere along the way it may call the function in kernel (counted in 'sys' time). After returning from the kernel call, there will be some more time in 'user' and then malloc will return to your code. As for when the switch happens, and how much of it is spent in kernel mode... you cannot say. It depends on the implementation of the library. Also, other seemingly innocent functions might also use malloc and the like in the background, which will again have some time in 'sys' then.
其实若是这些看完就知道了，我当时没有看这块内容，问笨神了，不得不说笨神大大很牛逼啊，直接告诉我有可能那个时候由于swap致使gc慢了，最后通过一系列验证的确是swap问题，把这个关闭就没有这块的问题了。其实相似linux很重要，须要重点学习下。
其实IO也很重要，在后面的一个问题虽然不是IO问题，可是笨神提到了是不是IO问题，也是须要关注的一个点，sar（System Activity Reporter系统活动状况报告）是目前 Linux 上最为全面的系统性能分析工具之一，能够从多方面对系统的活动进行报告，包括：文件的读写状况、系统调用的使用状况、磁盘I/O、CPU效率、内存使用情况、进程活动及IPC有关的活动等。一句话sar很是牛逼。
敲入“sar”，若是提示没有进行安装：
yum install sysstat
安装成功后，sar有不少明白包括不限于， 查看CPU使用率、查看平均负荷、查看内存使用状况、查看页面交换发生情况、查看I/O和传送速率的统计信息等，重点看看IO这块：
-d option in the sar command is used to display the block device statistics report. Using option -p (pretty-print) along with -d make the dev column more readable, example is shown below :
sar -d -p 1
等相关命令。
选择UseParallelOldGC垃圾回收器相关坑
- 新生代对象每经历依次minor gc，年龄会加一，当达到年龄阀值会直接进入老年代。阀值大小通常为15
- Survivor空间中年龄全部对象大小的总和大于survivor空间的一半，年龄大于或等于该年龄的对象就能够直接进入老年代，而无需等到年龄阀值
- 大对象直接进入老年代
- 新生代复制算法须要一个survivor区进行轮换备份，若是出现大量对象在minor gc后仍然存活的状况时，就须要老年代进行分配担保，让survivor没法容纳的对象直接进入老年代
先经过命令：
jstat -gc pid 3s发现S0、S1才512k，很奇怪，觉得是这块空间小了修改，-XX:SurvivorRatio=2，奇怪的问题发现啦，如图：
经过各类日志观察，见鬼啦，竟然S0、S1大小在愈来愈小，对、你没有看错，PS下UseAdaptiveSizePolicy默认是打开的，对问题就是在这里，经过命令：
jinfo -flag UseAdaptiveSizePolicy pid
的确是打开的，而CMS默认是关闭的，因此有些同窗可能也并无注意到这块内容，
该jvm实现代码在：
https://github.com/dmlloyd/openjdk/blob/jdk9/jdk9/hotspot/src/share/vm/gc/parallel/psAdaptiveSizePolicy.cpp
再此观察，日志里面一个相似age的都没有，觉得不是对象年龄到了晋升到old的，怀疑是对象过大了，经过加 -XX:PretenureSizeThreshold=100m参数（这个参数其实只对串行回收器和ParNew有效，对ParallelGC无效）， 再次观察，仍是old很涨，若是巨坑来了，纠结一夜。