【死磕JVM】看完这篇我也会排查JVM内存过高了就是玩儿！

前言

CPU 是时分的，操作系统里面有很多线程，每个线程的运行时间由CPU决定，CPU会分给每一个线程一个时间片，时间片是一个很短的时间长度，如果在时间片内，线程一直占有，就是100%，我们应该意识到，CPU运行速度很快(主频非常高)，除非是密集型耗费CPU的运算，其他类型的任务都会在小于时间片的时间内结束。

内存过高一般有两种情况：内存溢出和内存泄露

  • 内存溢出： 程序分配的内存超过物理机的内存大小，导致无法继续分配内存，出现OOM报错
  • 内存泄露： 不再使用的对象一直占据着内存不释放，导致这块内存浪费掉，久而久之，内存泄露的对象堆积起来，也会导致物理机的内存被耗尽，出现OOM报错

具体操作

如何监控JVM，我们可以通过一个案例在了解一些实际当中的操作，大家可以看到下面的代码，下面的代码只是模拟了当中的一个场景，一个风险控制的场景，一般银行或者第三方公司在向一个人发放贷款的时候，会调用这个人的征信已经还款能力，给出响应的评级。

 
 
 
 
    
  
  
  
  
  1. import java.math.BigDecimal; 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. import java.util.ArrayList; 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. import java.util.Date; 
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7. import java.util.List; 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9. import java.util.concurrent.ScheduledThreadPoolExecutor; 
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11. import java.util.concurrent.ThreadPoolExecutor; 
    12. 
  
  
  
  
  12.  
    13. 
  
  
  
  
  13. import java.util.concurrent.TimeUnit; 
    14. 
  
  
  
  
  14.  
    15. 
  
  
  
  
  15. public class FullGCTest { 
    16. 
  
  
  
  
  16.  
    17. 
  
  
  
  
  17. //模拟银行卡的类 
    18. 
  
  
  
  
  18.  
    19. 
  
  
  
  
  19. private static class CardInfo { 
    20. 
  
  
  
  
  20.  
    21. 
  
  
  
  
  21. //小农的银行卡信息记录 
    22. 
  
  
  
  
  22.  
    23. 
  
  
  
  
  23. BigDecimal price = new BigDecimal(10000000.0); 
    24. 
  
  
  
  
  24.  
    25. 
  
  
  
  
  25. String name = "牧小农"; 
    26. 
  
  
  
  
  26.  
    27. 
  
  
  
  
  27. int age = 18; 
    28. 
  
  
  
  
  28.  
    29. 
  
  
  
  
  29. Date birthdate = new Date(); 
    30. 
  
  
  
  
  30.  
    31. 
  
  
  
  
  31. public void m() {} 
    32. 
  
  
  
  
  32.  
    33. 
  
  
  
  
  33. } 
    34. 
  
  
  
  
  34.  
    35. 
  
  
  
  
  35. //线程池 定时线程池 
    36. 
  
  
  
  
  36.  
    37. 
  
  
  
  
  37. //50个，然后设置 拒绝策略 
    38. 
  
  
  
  
  38.  
    39. 
  
  
  
  
  39. private static ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(50, 
    40. 
  
  
  
  
  40.  
    41. 
  
  
  
  
  41. new ThreadPoolExecutor.DiscardOldestPolicy()); 
    42. 
  
  
  
  
  42.  
    43. 
  
  
  
  
  43. public static void main(String[] args) throws Exception { 
    44. 
  
  
  
  
  44.  
    45. 
  
  
  
  
  45. executor.setMaximumPoolSize(50); 
    46. 
  
  
  
  
  46.  
    47. 
  
  
  
  
  47. for (;;){ 
    48. 
  
  
  
  
  48.  
    49. 
  
  
  
  
  49. modelFit(); 
    50. 
  
  
  
  
  50.  
    51. 
  
  
  
  
  51. Thread.sleep(100); 
    52. 
  
  
  
  
  52.  
    53. 
  
  
  
  
  53. } 
    54. 
  
  
  
  
  54.  
    55. 
  
  
  
  
  55. } 
    56. 
  
  
  
  
  56.  
    57. 
  
  
  
  
  57. /** 
    58. 
  
  
  
  
  58.  
    59. 
  
  
  
  
  59. * 对银行卡进行风险评估 
    60. 
  
  
  
  
  60.  
    61. 
  
  
  
  
  61. */ 
    62. 
  
  
  
  
  62.  
    63. 
  
  
  
  
  63. private static void modelFit(){ 
    64. 
  
  
  
  
  64.  
    65. 
  
  
  
  
  65. List taskList = getAllCardInfo(); 
    66. 
  
  
  
  
  66.  
    67. 
  
  
  
  
  67. //拿出每一个信息出来 
    68. 
  
  
  
  
  68.  
    69. 
  
  
  
  
  69. taskList.forEach(info -> { 
    70. 
  
  
  
  
  70.  
    71. 
  
  
  
  
  71. // do something 
    72. 
  
  
  
  
  72.  
    73. 
  
  
  
  
  73. executor.scheduleWithFixedDelay(() -> { 
    74. 
  
  
  
  
  74.  
    75. 
  
  
  
  
  75. //调用M方法 
    76. 
  
  
  
  
  76.  
    77. 
  
  
  
  
  77. info.m(); 
    78. 
  
  
  
  
  78.  
    79. 
  
  
  
  
  79. }, 2, 3, TimeUnit.SECONDS); 
    80. 
  
  
  
  
  80.  
    81. 
  
  
  
  
  81. }); 
    82. 
  
  
  
  
  82.  
    83. 
  
  
  
  
  83. } 
    84. 
  
  
  
  
  84.  
    85. 
  
  
  
  
  85. private static List getAllCardInfo(){ 
    86. 
  
  
  
  
  86.  
    87. 
  
  
  
  
  87. List taskList = new ArrayList<>(); 
    88. 
  
  
  
  
  88.  
    89. 
  
  
  
  
  89. //每次查询100张卡出来 
    90. 
  
  
  
  
  90.  
    91. 
  
  
  
  
  91. for (int i = 0; i < 100; i++) { 
    92. 
  
  
  
  
  92.  
    93. 
  
  
  
  
  93. CardInfo ci = new CardInfo(); 
    94. 
  
  
  
  
  94.  
    95. 
  
  
  
  
  95. taskList.add(ci); 
    96. 
  
  
  
  
  96.  
    97. 
  
  
  
  
  97. } 
    98. 
  
  
  
  
  98.  
    99. 
  
  
  
  
  99. return taskList; 
    100. 
  
  
  
  
  100.  
    101. 
  
  
  
  
  101. } 
    102. 
  
  
  
  
  102.  
    103. 
  
  
  
  
  103. } 
    104.

程序的设计其实比较简单，就是我们用信用卡的案例来进行说明，比如CardInfo就是信用卡类，我们把这个人对应的信用卡的记录都调用出来，之后做一些自己响应的业务处理方法来对它进行处理和计算，来看看我们这个模型是否符合modelFit，具体怎么做呢，在应用程序中有一个类是CardInfo，有一个方法叫做getAllCardInfo，每次都是拿100个出来，拿100个之后用线程池做计算，线程池用的是 ScheduledThreadPoolExecutor(定时任务)，new出来线程池之后，50个线程池，然后做对应的业务逻辑处理，会调用 modelFit()，使用100毫秒模拟业务的停顿。

首先我们需要使用javac 命令将Java文件进行编译

  • javac FullGCTest.java 进行编译，然后打印GC日志，进行风险监控
  • 打印GC日志： java -Xms200M -Xmx200M -XX:+PrintGC FullGCTest

怎么知道JVM内存过高?

在公司里面，如果遇到了JVM内存过高的情况，那么一般是运维团队首先受到报警信息，然后通知对应的开发人员去查看，那么开发人员应该如何查看，或者怎么样去排查呢?

1、top 查看进程

受到报警信息后，拿top命令去查询

 
 
 
 
    
  
  
  
  
  1. [root@root ~]# top 
    2.

查看内存不断增长，CPU占用率居高不下的。top后你会看到它的PID(31061)。它占比比较高。

2、top -Hp 查看线程

找到CPU占用比较高的进程PID，这里我们以 java 的进程为例 使用命令 top -Hp 31061 ，这个时候它会把这个进程里面所有的线程全部线程都罗列出来吗，这些都是Java这个进程里面内部的一些线程，如下图所示：

我们会看到每个线程的占比都差不多，偶尔会有某一个线程比较高，在某些线程占得比较高的时候，这个小例子最终会是垃圾回收的线程占得比较高，因为垃圾回收不过来了，所以需要不停的来回回收，每次都回收一点点，实际这种例子里面非常有可能是你业务逻辑线程，那一块的业务逻辑线程占比非常高，这是时候就需要用到另外的命令——jstack

3、jstack

当我们使用 top -Hp 知道了是哪个线程后，我们下一步就可以使用 jstack命令，比如我们要查看31083这个线程号，31061是我们的进程PID，我们要定位某一个线程cpu的占比会比其他cpu高很多，那么我们就要定位这个线程里面到底是什么样的问题的时候，就需要把这个线程号(31083)记下来。

因为 jstack 用到的线程号是16进制的，所以我们需要把31083的10进制转换成16进制才可以

特点：

每个线程有自己的线程号码，里面有线程的状态，可以观察线程是否阻塞，如果长时间的wait和block说明这个线程是有问题的

4、转换16进制

因为Java线程文件中的线程ID是16进制，所以需要将线程ID从十进制转换成十六进制

 
 
 
 
    
  
  
  
  
  1. 命令：echo "obase=16;31083" | bc 
    2.

5、jstack用法解析

 
 
 
 
    
  
  
  
  
  1. [root@root ~]# jstack 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. Usage: 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. jstack [-l]  
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7. (to connect to running process) 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9. jstack -F [-m] [-l]  
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11. (to connect to a hung process) 
    12. 
  
  
  
  
  12.  
    13. 
  
  
  
  
  13. jstack [-m] [-l]  
    14. 
  
  
  
  
  14.  
    15. 
  
  
  
  
  15. (to connect to a core file) 
    16. 
  
  
  
  
  16.  
    17. 
  
  
  
  
  17. jstack [-m] [-l] [server_id@] 
    18. 
  
  
  
  
  18.  
    19. 
  
  
  
  
  19. (to connect to a remote debug server) 
    20. 
  
  
  
  
  20.  
    21. 
  
  
  
  
  21. Options: 
    22. 
  
  
  
  
  22.  
    23. 
  
  
  
  
  23. -F to force a thread dump. Use when jstack does not respond (process is hung) 
    24. 
  
  
  
  
  24.  
    25. 
  
  
  
  
  25. -m to print both java and native frames (mixed mode) 
    26. 
  
  
  
  
  26.  
    27. 
  
  
  
  
  27. -l long listing. Prints additional information about locks 
    28. 
  
  
  
  
  28.  
    29. 
  
  
  
  
  29. -h or -help to print this help message 
    30.

6、jstack查看输出

我们也可以用 jps或者java ps -ef| java 来查看Java进程，这里我们用jps来查看

 
 
 
 
    
  
  
  
  
  1. [root@root ~]# jps 
    2. 
 
 
 
 
 
 
 
 
    
  
  
  
  
  1. [root@root ~]# jstack 31061 
    2. 
 
 
 
 

 
 
 
 
    
  
  
  
  
  1. "pool-1-thread-3" #10 prio=5 os_prio=0 tid=0x00007f3568105800 nid=0x7961 waiting on condition [0x00007f35455cf000] 
    2. 
  
  
  
  
  2.    java.lang.Thread.State: WAITING (parking) 
    3. 
  
  
  
  
  3.         at sun.misc.Unsafe.park(Native Method) 
    4. 
  
  
  
  
  4.         - parking to wait for  <0x00000000f8a81148> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) 
    5. 
  
  
  
  
  5.         at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175) 
    6. 
  
  
  
  
  6.         at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2039) 
    7. 
  
  
  
  
  7.         at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(ScheduledThreadPoolExecutor.java:1088) 
    8. 
  
  
  
  
  8.         at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(ScheduledThreadPoolExecutor.java:809) 
    9. 
  
  
  
  
  9.         at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1074) 
    10. 
  
  
  
  
  10.         at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1134) 
    11. 
  
  
  
  
  11.         at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624) 
    12. 
  
  
  
  
  12.         at java.lang.Thread.run(Thread.java:748) 
    13. 
  
  
  
  
  13. "pool-1-thread-2" #9 prio=5 os_prio=0 tid=0x00007f3568103800 nid=0x7960 waiting on condition [0x00007f35456d0000] 
    14. 
  
  
  
  
  14.    java.lang.Thread.State: WAITING (parking) 
    15. 
  
  
  
  
  15.         at sun.misc.Unsafe.park(Native Method) 
    16. 
  
  
  
  
  16.         - parking to wait for  <0x00000000f8a81148> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) 
    17. 
  
  
  
  
  17.         at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175) 
    18. 
  
  
  
  
  18.         at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2039) 
    19. 
  
  
  
  
  19.         at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(ScheduledThreadPoolExecutor.java:1088) 
    20. 
  
  
  
  
  20.         at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(ScheduledThreadPoolExecutor.java:809) 
    21. 
  
  
  
  
  21.         at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1074) 
    22. 
  
  
  
  
  22.         at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1134) 
    23. 
  
  
  
  
  23.         at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624) 
    24. 
  
  
  
  
  24.         at java.lang.Thread.run(Thread.java:748) 
    25. 
  
  
  
  
  25.  
    26. 
  
  
  
  
  26. "pool-1-thread-1" #8 prio=5 os_prio=0 tid=0x00007f3568102000 nid=0x795f waiting on condition [0x00007f35457d1000] 
    27. 
  
  
  
  
  27.    java.lang.Thread.State: WAITING (parking) 
    28. 
  
  
  
  
  28.         at sun.misc.Unsafe.park(Native Method) 
    29. 
  
  
  
  
  29.         - parking to wait for  <0x00000000f8a81148> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject) 
    30. 
  
  
  
  
  30.         at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175) 
    31. 
  
  
  
  
  31.         at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2039) 
    32. 
  
  
  
  
  32.         at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(ScheduledThreadPoolExecutor.java:1088) 
    33. 
  
  
  
  
  33.         at java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(ScheduledThreadPoolExecutor.java:809) 
    34. 
  
  
  
  
  34.         at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1074) 
    35. 
  
  
  
  
  35.         at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1134) 
    36. 
  
  
  
  
  36.         at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624) 
    37. 
  
  
  
  
  37.         at java.lang.Thread.run(Thread.java:748) 
    38. 
  
  
  
  
  38.  
    39. 
  
  
  
  
  39. "Service Thread" #7 daemon prio=9 os_prio=0 tid=0x00007f35680b4000 nid=0x795d runnable [0x0000000000000000] 
    40. 
  
  
  
  
  40.    java.lang.Thread.State: RUNNABLE 
    41. 
  
  
  
  
  41.  
    42. 
  
  
  
  
  42. "C1 CompilerThread1" #6 daemon prio=9 os_prio=0 tid=0x00007f35680b1000 nid=0x795c waiting on condition [0x0000000000000000] 
    43. 
  
  
  
  
  43.    java.lang.Thread.State: RUNNABLE 
    44. 
  
  
  
  
  44.  
    45. 
  
  
  
  
  45. "C2 CompilerThread0" #5 daemon prio=9 os_prio=0 tid=0x00007f35680af000 nid=0x795b waiting on condition [0x0000000000000000] 
    46. 
  
  
  
  
  46.    java.lang.Thread.State: RUNNABLE 
    47. 
  
  
  
  
  47.  
    48. 
  
  
  
  
  48. "Signal Dispatcher" #4 daemon prio=9 os_prio=0 tid=0x00007f35680ad800 nid=0x795a runnable [0x0000000000000000] 
    49. 
  
  
  
  
  49.    java.lang.Thread.State: RUNNABLE 
    50. 
  
  
  
  
  50.  
    51. 
  
  
  
  
  51. "Finalizer" #3 daemon prio=8 os_prio=0 tid=0x00007f356807c800 nid=0x7959 in Object.wait() [0x00007f3558301000] 
    52. 
  
  
  
  
  52.    java.lang.Thread.State: WAITING (on object monitor) 
    53. 
  
  
  
  
  53.         at java.lang.Object.wait(Native Method) 
    54. 
  
  
  
  
  54.         - waiting on <0x00000000f8a86b38> (a java.lang.ref.ReferenceQueue$Lock) 
    55. 
  
  
  
  
  55.         at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:144) 
    56. 
  
  
  
  
  56.         - locked <0x00000000f8a86b38> (a java.lang.ref.ReferenceQueue$Lock) 
    57. 
  
  
  
  
  57.         at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:165) 
    58. 
  
  
  
  
  58.         at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:216) 
    59. 
  
  
  
  
  59.  
    60. 
  
  
  
  
  60. "Reference Handler" #2 daemon prio=10 os_prio=0 tid=0x00007f3568077800 nid=0x7958 in Object.wait() [0x00007f3558402000] 
    61. 
  
  
  
  
  61.    java.lang.Thread.State: WAITING (on object monitor) 
    62. 
  
  
  
  
  62.         at java.lang.Object.wait(Native Method) 
    63. 
  
  
  
  
  63.         - waiting on <0x00000000f8a86cf0> (a java.lang.ref.Reference$Lock) 
    64. 
  
  
  
  
  64.         at java.lang.Object.wait(Object.java:502) 
    65. 
  
  
  
  
  65.         at java.lang.ref.Reference.tryHandlePending(Reference.java:191) 
    66. 
  
  
  
  
  66.         - locked <0x00000000f8a86cf0> (a java.lang.ref.Reference$Lock) 
    67. 
  
  
  
  
  67.         at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:153) 
    68. 
  
  
  
  
  68.  
    69. 
  
  
  
  
  69. "main" #1 prio=5 os_prio=0 tid=0x00007f3568009800 nid=0x7956 waiting on condition [0x00007f356ed59000] 
    70. 
  
  
  
  
  70.    java.lang.Thread.State: TIMED_WAITING (sleeping) 
    71. 
  
  
  
  
  71.         at java.lang.Thread.sleep(Native Method) 
    72. 
  
  
  
  
  72.         at FullGCTest.main(FullGCTest.java:35) 
    73. 
  
  
  
  
  73.  
    74. 
  
  
  
  
  74. "VM Thread" os_prio=0 tid=0x00007f356806e000 nid=0x7957 runnable  
    75. 
  
  
  
  
  75.  
    76. 
  
  
  
  
  76. "VM Periodic Task Thread" os_prio=0 tid=0x00007f35680b7000 nid=0x795e waiting on condition  
    77. 
  
  
  
  
  77.  
    78. 
  
  
  
  
  78. JNI global references: 205 
    79.

 通过thread dump分析线程状态

大多数情况下会基于thead dump 分析当前各个线程的运行情况，如是否存在死锁，是否存在一个线程长时间持有锁不释放等等

在dump中，线程一般存在如下几种状态：1、RUNNABLE，线程处于执行中 2、BLOCKED，线程被阻塞 3、WAITING，线程正在等待

  • locked <0x000000076bf62208> 说明线程 对地址为0x000000076bf62208对象进行了加锁;waiting to lock <0x000000076bf62208> 说明线程 在等待地址为0x000000076bf62208对象上的锁;waiting for monitor entry [0x000000001e21f000]说明线程 是通过synchronized关键字进入了监视器的临界区，并处于"Entry Set"队列，等待monitor;waiting on <0x0000000088ca3310> (a java.lang.Object)等待锁的释放
  • 假如有一个进程中有100个线程，很多线程都在waiting on 某一把锁，然后线程不该阻塞的被阻塞了，该结束的没结束掉，一定要找到哪个线程持有这把锁 ，我们可以搜索 jstack dump 的信息，找到 <0X...> 的信息，看哪个线程只有了这把锁，一般这个线程状态是RUNNABLE，表示这个线程正在运行但是一直持有这把锁不释放，那么就会导致整个线程的死锁

7、jstack分析死锁

 
 
 
 
    
  
  
  
  
  1. public class TestDeadLock { 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. private static Object obj1 = new Object(); 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. private static Object obj2 = new Object(); 
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7. public static void main(String[] args) { 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9. new Thread(new Thread1()).start(); 
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11. new Thread(new Thread2()).start(); 
    12. 
  
  
  
  
  12.  
    13. 
  
  
  
  
  13. } 
    14. 
  
  
  
  
  14.  
    15. 
  
  
  
  
  15. private static class Thread1 implements Runnable { 
    16. 
  
  
  
  
  16.  
    17. 
  
  
  
  
  17. @Override 
    18. 
  
  
  
  
  18.  
    19. 
  
  
  
  
  19. public void run() { 
    20. 
  
  
  
  
  20.  
    21. 
  
  
  
  
  21. synchronized (obj1) { 
    22. 
  
  
  
  
  22.  
    23. 
  
  
  
  
  23. System.out.println("Thread1 拿到了 obj1 的锁!"); 
    24. 
  
  
  
  
  24.  
    25. 
  
  
  
  
  25. try {// 停顿2秒的意义在于，让Thread2线程拿到obj2的锁 
    26. 
  
  
  
  
  26.  
    27. 
  
  
  
  
  27. Thread.sleep(2000); 
    28. 
  
  
  
  
  28.  
    29. 
  
  
  
  
  29. } catch (InterruptedException e) { 
    30. 
  
  
  
  
  30.  
    31. 
  
  
  
  
  31. e.printStackTrace(); 
    32. 
  
  
  
  
  32.  
    33. 
  
  
  
  
  33. } 
    34. 
  
  
  
  
  34.  
    35. 
  
  
  
  
  35. synchronized (obj2) { 
    36. 
  
  
  
  
  36.  
    37. 
  
  
  
  
  37. System.out.println("Thread1 拿到了 obj2 的锁!"); 
    38. 
  
  
  
  
  38.  
    39. 
  
  
  
  
  39. } 
    40. 
  
  
  
  
  40.  
    41. 
  
  
  
  
  41. } 
    42. 
  
  
  
  
  42.  
    43. 
  
  
  
  
  43. } 
    44. 
  
  
  
  
  44.  
    45. 
  
  
  
  
  45. } 
    46. 
  
  
  
  
  46.  
    47. 
  
  
  
  
  47. private static class Thread2 implements Runnable { 
    48. 
  
  
  
  
  48.  
    49. 
  
  
  
  
  49. @Override 
    50. 
  
  
  
  
  50.  
    51. 
  
  
  
  
  51. public void run() { 
    52. 
  
  
  
  
  52.  
    53. 
  
  
  
  
  53. synchronized (obj2) { 
    54. 
  
  
  
  
  54.  
    55. 
  
  
  
  
  55. System.out.println("Thread2 拿到了 obj2 的锁!"); 
    56. 
  
  
  
  
  56.  
    57. 
  
  
  
  
  57. try { 
    58. 
  
  
  
  
  58.  
    59. 
  
  
  
  
  59. // 停顿2秒的意义在于，让Thread1线程拿到obj1的锁 
    60. 
  
  
  
  
  60.  
    61. 
  
  
  
  
  61. Thread.sleep(2000); 
    62. 
  
  
  
  
  62.  
    63. 
  
  
  
  
  63. } catch (Exception e) { 
    64. 
  
  
  
  
  64.  
    65. 
  
  
  
  
  65. e.printStackTrace(); 
    66. 
  
  
  
  
  66.  
    67. 
  
  
  
  
  67. } 
    68. 
  
  
  
  
  68.  
    69. 
  
  
  
  
  69. synchronized (obj1) { 
    70. 
  
  
  
  
  70.  
    71. 
  
  
  
  
  71. System.out.println("Thread2 拿到了obj1的锁!"); 
    72. 
  
  
  
  
  72.  
    73. 
  
  
  
  
  73. } 
    74. 
  
  
  
  
  74.  
    75. 
  
  
  
  
  75. } 
    76. 
  
  
  
  
  76.  
    77. 
  
  
  
  
  77. } 
    78. 
  
  
  
  
  78.  
    79. 
  
  
  
  
  79. } 
    80. 
  
  
  
  
  80.  
    81. 
  
  
  
  
  81. } 
    82.

通过命令查看分析日志

 
 
 
 
    
  
  
  
  
  1. [root@root fuccGC]# jps 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. 485 Bootstrap 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. 9877 Jps 
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7. 10629 QuorumPeerMain 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9. 9846 TestDeadLock 
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11. [root@root fuccGC]# jstack 9846 
    12.

内存监控工具的使用

我们可以使用jvm自带的命令去进行监控GC的信息： jinfo pid： 这个命令就是把这个进程的一些详细信息列出来

 
 
 
 
    
  
  
  
  
  1. [root@root ~]# jinfo 9846 
    2.

这个只是有帮助，但是帮助不是特别大，大家只要记住有这个命令就行，不做深入了解

jstat -gc pid 1000： 这个就是每一秒钟将GC的日志打印出来，动态 观察GC情况/阅读GC日志发现频繁GC等等，但是这个信息看起来不是很直观，能够分析出来的东西也不多，所以一般使用的也不是很多

我们用的最多的还是通过工具去查看，比如 jconsole/jvisualvm

1、 jconsole

这两个是JDK自带的一个工具，也是 一个图形界面的工具，只要你装了JDK就有这两个工具，可以从本机去跟踪远程服务器上的一个进程，作为Linux服务器，很少有人会装图形界面，如下图所示：

在我们程序启动的时候要加入参数：

 
 
 
 
    
  
  
  
  
  1. java -Djava.rmi.server.hostname=101.XX.XXX.XX -Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.port=8080 -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false -Dcom.sun.management.jmxremote.rmi.port=8080 FullGCTes 
    2.

基本情况如下，我们就可以监控到我们远程服务器上面的内存信息

2、 jvisualvm

双击 jvisualvm

选择远程-点击文件按钮

选择添加JMX连接

输入我们的地址和账号密码就可以登录了

这样就可以查看我们远程服务的内存信息了

在这里我们就知道怎么定位问题了，哪一个类占用了多少内存，就会显示出来，点击抽样器，内存，之后就会对远程的那台机器的JAVA进程内存，在图形化界面中显示，有多少个类，占用了多少个字节，这样我们就可以具体定位到是哪个类有问题了

面试中如何回答定位内存溢出(OOM)

如果面试官我们如何定位OOM的问题，但是我们不能回答用图形界面，因为作为一个服务来讲，在不断的运行，当我们开一个JMX服务的时候，会形象服务本来的运行效率，那我们已经上线的系统不用图形化用什么?还有一个叫Jprofiler是最好用的图形界面，但是这个是收费的，所以一般用不到，

如果不用图形界面那我们用什么，我们可以用 cmdline、arthas这两个 图形界面用在什么地方呢?用在测试上，测试的时候进行监控~

如果已经上线的项目，我们不用图形界面可以用什么呢?我们可以用Jmap

jmap

 
 
 
 
    
  
  
  
  
  1. [root@root~]#jmap-histo19086|head-20  
    2.

它就会把我们的内存信息打印出来，虽然没有图形化界面方便，但是里面的信息也足够我们去观察和定位问题了

线上系统，内存特别大，jmap执行期间会对进程产生很大影响，甚至卡顿(电商不适合)

  1. 设定了参数HeapDump，OOM的时候会自动产生堆转储文件( java-Xms20M-Xmx20M-XX:+UseParallelGC-XX:+HeapDumpOnOutOfMemoryErrorFullGCTest)
  2. 很多服务器备份(高可用)，停掉这台服务器对其他服务器不影响
  3. 下期讲解，哈哈哈

当前标题：【死磕JVM】看完这篇我也会排查JVM内存过高了就是玩儿！
分享URL：http://www.shufengxianlan.com/qtweb/news10/363960.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

服务器托管知识

分类信息网

王君美油画　　 　成都网站设计　　 　软文推广　　 　成都网页设计　　 　成都酒店服定制　　 　成都网站建设公司　　 　成都网站建设哪家好　　 　企业网站设计　　 　成都网站推广营销　　 　虚拟主机　　 　营销型网站建设　　 　注册域名　　 　成都企业网站建设　　 　成都西云机房　　 　成都网站建设公司　　 　南充网站建设　　 　成都网站制作　　 　成都定制网站　　 　成都网站设计　　 　网站seo优化