`
jiagou
  • 浏览: 2537446 次
文章分类
社区版块
存档分类
最新评论

Java性能调优笔记

 
阅读更多

Java性能调优笔记

调优步骤：衡量系统现状、设定调优目标、寻找性能瓶颈、性能调优、衡量是否到达目标(如果未到达目标，需重新寻找性能瓶颈）、性能调优结束。


寻找性能瓶颈
性能瓶颈的表象：资源消耗过多、外部处理系统的性能不足、资源消耗不多但程序的响应速度却仍达不到要求。

资源消耗：CPU、文件IO、网络IO、内存。
外部处理系统的性能不足：所调用的其他系统提供的功能或数据库操作的响应速度不够。
资源消耗不多但程序的响应速度却仍达不到要求：程序代码运行效率不够高、未充分使用资源、程序结构不合理。


CPU消耗分析
CPU主要用于中断、内核、用户进程的任务处理，优先级为中断>内核>用户进程。

上下文切换：
每个线程分配一定的执行时间，当到达执行时间、线程中有IO阻塞或高优先级线程要执行时，将切换执行的线程。在切换时要存储目前线程的执行状态，并恢复要执行的线程的状态。
对于Java应用，典型的是在进行文件IO操作、网络IO操作、锁等待、线程Sleep时，当前线程会进入阻塞或休眠状态，从而触发上下文切换，上下文切换过多会造成内核占据较多的CPU的使用。

运行队列：
每个CPU核都维护一个可运行的线程队列。系统的load主要由CPU的运行队列来决定。
运行队列值越大，就意味着线程会要消耗越长的时间才能执行完成。

利用率：
CPU在用户进程、内核、中断处理、IO等待、空闲，这五个部分使用百分比。


文件IO消耗分析
Linux在操作文件时，将数据放入文件缓存区，直到内存不够或系统要释放内存给用户进程使用。所以通常情况下只有写文件和第一次读取文件时会产生真正的文件IO。
对于Java应用，造成文件IO消耗高主要是多个线程需要进行大量内容写入（例如频繁的日志写入）的动作、磁盘设备本身的处理速度慢、文件系统慢、操作的文件本身已经很大。


网络IO消耗分析
对于分布式Java应用，网卡中断是不是均衡分配到各CPU(cat/proc/interrupts查看)。


内存消耗分析（-Xms和-Xmx设为相同的值，避免运行期JVM堆内存要不断申请内存）
对于Java应用，内存的消耗主要在Java堆内存上，只有创建线程和使用Direct ByteBuffer才会操作JVM堆外的内存。
JVM内存消耗过多会导致GC执行频繁，CPU消耗增加，应用线程的执行速度严重下降，甚至造成OutOfMemoryError，最终导致Java进程退出。

JVM堆外的内存
swap的消耗、物理内存的消耗、JVM内存的消耗。

程序执行慢原因分析

锁竞争激烈：很多线程竞争互斥资源，但资源有限， 造成其他线程都处于等待状态。

未充分使用硬件资源：线程操作被串行化。

数据量增长：单表数据量太大（如1个亿）造成数据库读写速度大幅下降（操作此表）。

调优

JVM调优（最关键参数为：-Xms -Xmx -Xmn -XX:SurvivorRatio -XX:MaxTenuringThreshold）

代大小调优：避免新生代大小设置过小、避免新生代大小设置过大、避免Survivor设置过小或过大、合理设置新生代存活周期。

-Xmn 调整新生代大小，新生代越大通常也意味着更多对象会在minor GC阶段被回收，但可能有可能造成旧生代大小，造成频繁触发Full GC，甚至是OutOfMemoryError。

-XX:SurvivorRatio调整Eden区与Survivor区的大小，Eden 区越大通常也意味着minor GC发生频率越低，但可能有可能造成Survivor区太小，导致对象minor GC后就直接进入旧生代，从而更频繁触发Full GC。

GC策略的调优：CMS GC多数动作是和应用并发进行的，确实可以减小GC动作给应用造成的暂停时间。对于Web应用非常需要一个对应用造成暂停时间短的GC，再加上Web应用 的瓶颈都不在CPU上，在G1还不够成熟的情况下，CMS GC是不错的选择。

（如果系统不是CPU密集型，且从新生代进入旧生代的大部分对象是可以回收的，那么采用CMS GC可以更好地在旧生代满之前完成对象的回收，更大程度降低Full GC发生的可能）

在调整了内存管理方面的参数后应通过-XX:PrintGCDetails、-XX:+PrintGCTimeStamps、 -XX:+PrintGCApplicationStoppedTime以及jstat或visualvm等方式观察调整后的GC状况。

出内存管理以外的其他方面的调优参数：-XX:CompileThreshold、-XX:+UseFastAccessorMethods、 -XX:+UseBaiasedLocking。

程序调优

CPU消耗严重的解决方法

CPU us高的解决方法：

CPU us 高的原因主要是执行线程不需要任何挂起动作，且一直执行，导致CPU 没有机会去调度执行其他的线程。

调优方案： 增加Thread.sleep，以释放CPU 的执行权，降低CPU 的消耗。以损失单次执行性能为代价的，但由于其降低了CPU 的消耗，对于多线程的应用而言，反而提高了总体的平均性能。

（在实际的Java应用中类似场景， 对于这种场景最佳方式是改为采用wait/notify机制）

对于其他类似循环次数过多、正则、计算等造成CPU us过高的状况， 则需要结合业务调优。

对于GC频繁，则需要通过JVM调优或程序调优，降低GC的执行次数。

CPU sy高的解决方法：

CPU sy 高的原因主要是线程的运行状态要经常切换，对于这种情况，常见的一种优化方法是减少线程数。

调优方案： 将线程数降低

这种调优过后有可能会造成CPU us过高，所以合理设置线程数非常关键。

对于Java分布式应用，还有一种典型现象是应用中有较多的网络IO操作和确实需要一些锁竞争机制（如数据库连接池），但为了能够支撑搞得并发量，可采用协程（Coroutine）来支撑更高的并发量，避免并发量上涨后造成CPU sy消耗严重、系统load迅速上涨和系统性能下降。

在Java中实现协程的框架有Kilim，Kilim执行一项任务创建Task，使用Task的暂停机制，而不是Thread，Kilim承担了线程调度以及上下切换动作，Task相对于原生Thread而言就轻量级多了，且能更好利用CPU。Kilim带来的是线程使用率的提升，但同时由于要在JVM堆中保存Task上下文信息，因此在采用Kilim的情况下要消耗更多的内存。（目前JDK 7中也有一个支持协程方式的实现，另外基于JVM的Scala的Actor也可用于在Java使用协程）

文件IO消耗严重的解决方法

从程序的角度而言，造成文件IO消耗严重的原因主要是多个线程在写进行大量的数据到同一文件，导致文件很快变得很大，从而写入速度越来越慢，并造成各线程激烈争抢文件锁。

常用调优方法：

异步写文件

批量读写

限流

限制文件大小

网络IO消耗严重的解决方法

从程序的角度而言，造成网络IO消耗严重的原因主要是同时需要发送或接收的包太多。

常用调优方法：

限流，限流通常是限制发送packet的频率，从而在网络IO消耗可接受的情况下来发送packget。

内存消耗严重的解决方法

释放不必要的引用：代码持有了不需要的对象引用，造成这些对象无法被GC，从而占据了JVM堆内存。（使用ThreadLocal：注意在线程内动作执行完毕时，需执行ThreadLocal.set把对象清除，避免持有不必要的对象引用）

使用对象缓存池：创建对象要消耗一定的CPU以及内存，使用对象缓存池一定程度上可降低JVM堆内存的使用。

采用合理的缓存失效算法：如果放入太多对象在缓存池中，反而会造成内存的严重消耗， 同时由于缓存池一直对这些对象持有引用，从而造成Full GC增多，对于这种状况要合理控制缓存池的大小，避免缓存池的对象数量无限上涨。（经典的缓存失效算法来清除缓存池中的对象：FIFO、LRU、LFU等）

合理使用SoftReference和WeekReference：SoftReference的对象会在内存不够用的时候回收，WeekReference的对象会在Full GC的时候回收。

资源消耗不多但程序执行慢的情况的解决方法

降低锁竞争： 多线多了，锁竞争的状况会比较明显，这时候线程很容易处于等待锁的状况，从而导致性能下降以及CPU sy上升。

使用并发包中的类：大多数采用了lock-free、nonblocking算法。

使用Treiber算法：基于CAS以及AtomicReference。

使用Michael-Scott非阻塞队列算法：基于CAS以及AtomicReference，典型ConcurrentLindkedQueue。

（基于CAS和AtomicReference来实现无阻塞是不错的选择，但值得注意的是，lock-free算法需不断的循环比较来保证资源的一致性的，对于冲突较多的应用场景而言，会带来更高的CPU消耗，因此不一定采用CAS实现无阻塞的就一定比采用lock方式的性能好。 还有一些无阻塞算法的改进：MCAS、WSTM等）

尽可能少用锁：尽可能只对需要控制的资源做加锁操作（通常没有必要对整个方法加锁，尽可能让锁最小化，只对互斥及原子操作的地方加锁，加锁时尽可能以保护资源的最小化粒度为单位--如只对需要保护的资源加锁而不是this）。

拆分锁：独占锁拆分为多把锁（读写锁拆分、类似ConcurrentHashMap中默认拆分为16把锁），很多程度上能提高读写的性能，但需要注意在采用拆分锁后，全局性质的操作会变得比较复杂（如ConcurrentHashMap中size操作）。（拆分锁太多也会造成副作用，如CPU消耗明显增加）

去除读写操作的互斥：在修改时加锁，并复制对象进行修改，修改完毕后切换对象的引用，从而读取时则不加锁。这种称为CopyOnWrite，CopyOnWriteArrayList是典型实现，好处是可以明显提升读的性能，适合读多写少的场景， 但由于写操作每次都要复制一份对象，会消耗更多的内存。

充分利用硬件资源（CPU和内存）：

充分利用CPU

在能并行处理的场景中未使用足够的线程（线程增加：CPU资源消耗可接受且不会带来激烈竞争锁的场景下）， 例如单线程的计算，可以拆分为多个线程分别计算，最后将结果合并，JDK 7中的fork-join框架。

Amdahl定律公式：1/(F+(1-F)/N)。

充分利用内存

数据的缓存、耗时资源的缓存（数据库连接创建、网络连接的创建等）、页面片段的缓存。

毕竟内存的读取肯定远快于硬盘、网络的读取， 在内存消耗可接受、GC频率、以及系统结构（例如集群环境可能会带来缓存的同步）可接受情况下，应充分利用内存来缓存数据，提升系统的性能。

总结：

好的调优策略是收益比（调优后提升的效果/调优改动所需付出的代价）最高的，通常来说简单的系统调优比较好做，因此尽量保持单机上应用的纯粹性， 这是大型系统的基本架构原则。

调优的三大有效原则：充分而不过分使用硬件资源、合理调整JVM、合理使用JDK包。

学习参考资料：

《分布式Java应用：基础与实践》

补充《分布式Java应用：基础与实践》一些代码样例：

cpu-----------------------------------

CpuNotUseEffectiveDemo

[java]view plaincopy
  1. /**
  2. *
  3. */
  4. packagetune.program.cpu;
  5. importjava.util.ArrayList;
  6. importjava.util.List;
  7. importjava.util.Random;
  8. /**
  9. *未充分利用CPU：在能并行处理的场景中未使用足够的线程（线程增加：CPU资源消耗可接受且不会带来激烈竞争锁的场景下）
  10. *
  11. *@authoryangwmAug25,20109:54:50AM
  12. */
  13. publicclassCpuNotUseEffectiveDemo{
  15. privatestaticintexecuteTimes=10;
  16. privatestaticinttaskCount=200;
  18. publicstaticvoidmain(String[]args)throwsException{
  19. Tasktask=newTask();
  20. for(inti=0;i<taskCount;i++){
  21. task.addTask(Integer.toString(i));
  22. }
  24. longbeginTime=System.currentTimeMillis();
  25. for(inti=0;i<executeTimes;i++){
  26. System.out.println("Round:"+(i+1));
  27. Threadthread=newThread(task);
  28. thread.start();
  29. thread.join();
  30. }
  31. longendTime=System.currentTimeMillis();
  32. System.out.println("Executesummary:Round("+executeTimes+")TaskCountPerRound("+taskCount
  33. +")ExecuteTime("+(endTime-beginTime)+")ms");
  34. }
  36. staticclassTaskimplementsRunnable{
  37. List<String>tasks=newArrayList<String>();
  38. Randomrandom=newRandom();
  39. booleanexitFlag=false;
  41. publicvoidaddTask(Stringtask){
  42. List<String>copyTasks=newArrayList<String>(tasks);
  43. copyTasks.add(task);
  45. tasks=copyTasks;
  46. }
  47. @Override
  48. publicvoidrun(){
  49. List<String>runTasks=tasks;
  50. List<String>removeTasks=newArrayList<String>();
  51. for(Stringtask:runTasks){
  52. try{
  53. Thread.sleep(random.nextInt(10));
  54. }catch(Exceptione){
  55. e.printStackTrace();
  56. }
  58. removeTasks.add(task);
  59. }
  61. try{
  62. Thread.sleep(10);
  63. }catch(Exceptione){
  64. e.printStackTrace();
  65. }
  66. }
  68. }
  70. }
  71. /*
  72. Round:1
  73. ......
  74. Round:10
  75. Executesummary:Round(10)TaskCountPerRound(200)ExecuteTime(10687)ms
  76. */

CpuUseEffectiveDemo

[java]view plaincopy
  1. /**
  2. *
  3. */
  4. packagetune.program.cpu;
  5. importjava.util.ArrayList;
  6. importjava.util.List;
  7. importjava.util.Random;
  8. importjava.util.concurrent.CountDownLatch;
  10. /**
  11. *充分利用CPU：在能并行处理的场景中使用足够的线程（线程增加：CPU资源消耗可接受且不会带来激烈竞争锁的场景下）
  12. *
  13. *@authoryangwmAug25,20109:54:50AM
  14. */
  15. publicclassCpuUseEffectiveDemo{
  17. privatestaticintexecuteTimes=10;
  18. privatestaticinttaskCount=200;
  19. privatestaticfinalintTASK_THREADCOUNT=16;
  20. privatestaticCountDownLatchlatch;
  22. publicstaticvoidmain(String[]args)throwsException{
  23. Task[]tasks=newTask[TASK_THREADCOUNT];
  24. for(inti=0;i<TASK_THREADCOUNT;i++){
  25. tasks[i]=newTask();
  26. }
  27. for(inti=0;i<taskCount;i++){
  28. intmod=i%TASK_THREADCOUNT;
  29. tasks[mod].addTask(Integer.toString(i));
  30. }
  32. longbeginTime=System.currentTimeMillis();
  33. for(inti=0;i<executeTimes;i++){
  34. System.out.println("Round:"+(i+1));
  35. latch=newCountDownLatch(TASK_THREADCOUNT);
  36. for(intj=0;j<TASK_THREADCOUNT;j++){
  37. Threadthread=newThread(tasks[j]);
  38. thread.start();
  39. }
  40. latch.await();
  41. }
  42. longendTime=System.currentTimeMillis();
  43. System.out.println("Executesummary:Round("+executeTimes+")TaskCountPerRound("+taskCount
  44. +")ExecuteTime("+(endTime-beginTime)+")ms");
  45. }
  47. staticclassTaskimplementsRunnable{
  48. List<String>tasks=newArrayList<String>();
  49. Randomrandom=newRandom();
  50. booleanexitFlag=false;
  52. publicvoidaddTask(Stringtask){
  53. List<String>copyTasks=newArrayList<String>(tasks);
  54. copyTasks.add(task);
  56. tasks=copyTasks;
  57. }
  58. @Override
  59. publicvoidrun(){
  60. List<String>runTasks=tasks;
  61. List<String>removeTasks=newArrayList<String>();
  62. for(Stringtask:runTasks){
  63. try{
  64. Thread.sleep(random.nextInt(10));
  65. }catch(Exceptione){
  66. e.printStackTrace();
  67. }
  69. removeTasks.add(task);
  70. }
  72. try{
  73. Thread.sleep(10);
  74. }catch(Exceptione){
  75. e.printStackTrace();
  76. }
  77. latch.countDown();
  78. }
  80. }
  82. }
  83. /*
  84. Round:1
  85. ......
  86. Round:10
  87. Executesummary:Round(10)TaskCountPerRound(200)ExecuteTime(938)ms
  88. */

fileio-------------------------------------------------------------------

IOWaitHighDemo

[java]view plaincopy
  1. /**
  2. *
  3. */
  4. packagetune.program.fileio;
  5. importjava.io.BufferedWriter;
  6. importjava.io.File;
  7. importjava.io.FileWriter;
  8. importjava.util.Random;
  9. /**
  10. *文件IO消耗严重的原因主要是多个线程在写进行大量的数据到同一文件，
  11. *导致文件很快变得很大，从而写入速度越来越慢，并造成各线程激烈争抢文件锁。
  12. *
  13. *@authoryangwmAug21,20109:48:34PM
  14. */
  15. publicclassIOWaitHighDemo{
  16. privateStringfileName="iowait.log";
  18. privatestaticintthreadCount=Runtime.getRuntime().availableProcessors();
  20. privateRandomrandom=newRandom();
  22. publicstaticvoidmain(String[]args)throwsException{
  23. if(args.length==1){
  24. threadCount=Integer.parseInt(args[1]);
  25. }
  27. IOWaitHighDemodemo=newIOWaitHighDemo();
  28. demo.runTest();
  29. }
  31. privatevoidrunTest()throwsException{
  32. Filefile=newFile(fileName);
  33. file.createNewFile();
  35. for(inti=0;i<threadCount;i++){
  36. newThread(newTask()).start();
  37. }
  39. }
  41. classTaskimplementsRunnable{
  42. @Override
  43. publicvoidrun(){
  44. while(true){
  45. try{
  46. StringBuilderstrBuilder=newStringBuilder("====begin====/n");
  47. StringthreadName=Thread.currentThread().getName();
  48. for(inti=0;i<100000;i++){
  49. strBuilder.append(threadName);
  50. strBuilder.append("/n");
  51. }
  52. strBuilder.append("====end====/n");
  54. BufferedWriterwriter=newBufferedWriter(newFileWriter(fileName,true));
  55. writer.write(strBuilder.toString());
  56. writer.close();
  57. Thread.sleep(random.nextInt(10));
  58. }catch(Exceptione){
  60. }
  61. }
  62. }
  64. }
  66. }
  67. /*
  68. C:/DocumentsandSettings/yangwm>jstack2656
  69. 2010-08-2123:24:17
  70. FullthreaddumpJavaHotSpot(TM)ClientVM(17.0-b05mixedmode):
  71. "DestroyJavaVM"prio=6tid=0x00868c00nid=0xde0waitingoncondition[0x00000000]
  72. java.lang.Thread.State:RUNNABLE
  73. "Thread-1"prio=6tid=0x0ab9dc00nid=0xb7crunnable[0x0b0bf000]
  74. java.lang.Thread.State:RUNNABLE
  75. atjava.io.FileOutputStream.close0(NativeMethod)
  76. atjava.io.FileOutputStream.close(FileOutputStream.java:336)
  77. atsun.nio.cs.StreamEncoder.implClose(StreamEncoder.java:320)
  78. atsun.nio.cs.StreamEncoder.close(StreamEncoder.java:149)
  79. -locked<0x034dd268>(ajava.io.FileWriter)
  80. atjava.io.OutputStreamWriter.close(OutputStreamWriter.java:233)
  81. atjava.io.BufferedWriter.close(BufferedWriter.java:265)
  82. -locked<0x034dd268>(ajava.io.FileWriter)
  83. attune.IOWaitHighDemo$Task.run(IOWaitHighDemo.java:58)
  84. atjava.lang.Thread.run(Thread.java:717)
  85. "Thread-0"prio=6tid=0x0ab9d400nid=0x80crunnable[0x0b06f000]
  86. java.lang.Thread.State:RUNNABLE
  87. atjava.io.FileOutputStream.writeBytes(NativeMethod)
  88. atjava.io.FileOutputStream.write(FileOutputStream.java:292)
  89. atsun.nio.cs.StreamEncoder.writeBytes(StreamEncoder.java:221)
  90. atsun.nio.cs.StreamEncoder.implWrite(StreamEncoder.java:282)
  91. atsun.nio.cs.StreamEncoder.write(StreamEncoder.java:125)
  92. -locked<0x034e1290>(ajava.io.FileWriter)
  93. atjava.io.OutputStreamWriter.write(OutputStreamWriter.java:207)
  94. atjava.io.BufferedWriter.flushBuffer(BufferedWriter.java:128)
  95. -locked<0x034e1290>(ajava.io.FileWriter)
  96. atjava.io.BufferedWriter.write(BufferedWriter.java:229)
  97. -locked<0x034e1290>(ajava.io.FileWriter)
  98. atjava.io.Writer.write(Writer.java:157)
  99. attune.IOWaitHighDemo$Task.run(IOWaitHighDemo.java:57)
  100. atjava.lang.Thread.run(Thread.java:717)
  101. "LowMemoryDetector"daemonprio=6tid=0x0ab6f800nid=0xfb0runnable[0x00000000]
  102. java.lang.Thread.State:RUNNABLE
  103. "CompilerThread0"daemonprio=10tid=0x0ab6c800nid=0x5fcwaitingoncondition[0x00000000]
  104. java.lang.Thread.State:RUNNABLE
  105. "AttachListener"daemonprio=10tid=0x0ab67800nid=0x6fcwaitingoncondition[0x00000000]
  106. java.lang.Thread.State:RUNNABLE
  107. "SignalDispatcher"daemonprio=10tid=0x0ab66800nid=0x5a0runnable[0x00000000]
  108. java.lang.Thread.State:RUNNABLE
  109. "Finalizer"daemonprio=8tid=0x0ab54000nid=0xe74inObject.wait()[0x0ac8f000]
  110. java.lang.Thread.State:WAITING(onobjectmonitor)
  111. atjava.lang.Object.wait(NativeMethod)
  112. -waitingon<0x02f15d90>(ajava.lang.ref.ReferenceQueue$Lock)
  113. atjava.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:135)
  114. -locked<0x02f15d90>(ajava.lang.ref.ReferenceQueue$Lock)
  115. atjava.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:151)
  116. atjava.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:177)
  117. "ReferenceHandler"daemonprio=10tid=0x0ab4f800nid=0x8a4inObject.wait()[0x0ac3f000]
  118. java.lang.Thread.State:WAITING(onobjectmonitor)
  119. atjava.lang.Object.wait(NativeMethod)
  120. -waitingon<0x02f15af8>(ajava.lang.ref.Reference$Lock)
  121. atjava.lang.Object.wait(Object.java:502)
  122. atjava.lang.ref.Reference$ReferenceHandler.run(Reference.java:133)
  123. -locked<0x02f15af8>(ajava.lang.ref.Reference$Lock)
  124. "VMThread"prio=10tid=0x0ab4a800nid=0x1d0runnable
  125. "VMPeriodicTaskThread"prio=10tid=0x0ab7d400nid=0x464waitingoncondition
  126. JNIglobalreferences:693
  128. C:/DocumentsandSettings/yangwm>
  129. */

LogControl

[java]view plaincopy
  1. /**
  2. *
  3. */
  4. packagetune.program.fileio;
  5. importjava.util.concurrent.atomic.AtomicInteger;
  6. /**
  7. *日志控制：采用简单策略为统计一段时间内日志输出频率，当超出这个频率时，一段时间内不再写log
  8. *
  9. *@authoryangwmAug24,201010:41:43AM
  10. */
  11. publicclassLogControl{
  13. publicstaticvoidmain(String[]args){
  14. for(inti=1;i<=1000;i++){
  15. if(LogControl.isLog()){
  16. //logger.error(errorInfo,throwable);
  17. System.out.println("errorInfo"+i);
  18. }
  20. //
  21. if(i%100==0){
  22. try{
  23. Thread.sleep(1000);
  24. }catch(InterruptedExceptione){
  25. e.printStackTrace();
  26. }
  27. }
  28. }
  29. }
  32. privatestaticfinallongINTERVAL=1000;
  33. privatestaticfinallongPUNISH_TIME=5000;
  34. privatestaticfinalintERROR_THRESHOLD=100;
  35. privatestaticAtomicIntegercount=newAtomicInteger(0);
  36. privatestaticlongbeginTime;
  37. privatestaticlongpunishTimeEnd;
  39. //由于控制不用非常精确，因此忽略此处的并发问题
  40. publicstaticbooleanisLog(){
  41. //System.out.println(count.get()+","+beginTime+","+punishTimeEnd+","+System.currentTimeMillis());
  43. //不写日志阶段
  44. if(punishTimeEnd>0&&punishTimeEnd>System.currentTimeMillis()){
  45. returnfalse;
  46. }
  48. //重新计数
  49. if(count.getAndIncrement()==0){
  50. beginTime=System.currentTimeMillis();
  51. returntrue;
  52. }else{//已在计数
  53. //超过阀门值，设置count为0并设置一段时间内不写日志
  54. if(count.get()>ERROR_THRESHOLD){
  55. count.set(0);
  56. punishTimeEnd=PUNISH_TIME+System.currentTimeMillis();
  57. returnfalse;
  58. }
  59. //没超过阀门值，且当前时间已超过计数周期，则重新计算
  60. elseif(System.currentTimeMillis()>(beginTime+INTERVAL)){
  61. count.set(0);
  62. }
  64. returntrue;
  65. }
  66. }
  68. }
  69. /*
  70. errorInfo1
  71. errorInfo2
  72. ......
  73. errorInfo99
  74. errorInfo100
  75. errorInfo601
  76. errorInfo602
  77. ......
  78. errorInfo699
  79. errorInfo700
  80. */

memory-------------------------------------------------------------------

MemoryHighDemo

[java]view plaincopy
  1. /**
  2. *
  3. */
  4. packagetune.program.memory;
  5. importjava.nio.ByteBuffer;
  6. /**
  7. *directbytebuffer消耗的是jvm堆外的内存，但同样是基于GC方式来释放的。
  8. *
  9. *@authoryangwmAug21,20109:40:18PM
  10. */
  11. publicclassMemoryHighDemo{
  13. publicstaticvoidmain(String[]args)throwsException{
  14. Thread.sleep(20000);
  15. System.out.println("readtocreatebytes,sojvmheapwillbeused");
  16. byte[]bytes=newbyte[128*1000*1000];
  17. bytes[0]=1;
  18. bytes[1]=2;
  19. Thread.sleep(10000);
  20. System.out.println("readtoallocate&putdirectbytebuffer,nojvmheapshouldbeused");
  21. ByteBufferbuffer=ByteBuffer.allocateDirect(128*1024*1024);
  22. buffer.put(bytes);
  23. buffer.flip();
  24. Thread.sleep(10000);
  25. System.out.println("readytogc,jvmheapwillbefreed");
  26. bytes=null;
  27. System.gc();
  28. Thread.sleep(10000);
  29. System.out.println("readtogetbytes,thenjvmheapwillbeused");
  30. byte[]resultbytes=newbyte[128*1000*1000];
  31. buffer.get(resultbytes);
  32. System.out.println("resultbytes[1]is:"+resultbytes[1]);
  33. Thread.sleep(10000);
  34. System.out.println("readtogcall");
  35. buffer=null;
  36. resultbytes=null;
  37. System.gc();
  38. Thread.sleep(10000);
  39. }
  41. }
  42. /*
  43. D:/study/tempProject/JavaLearn/classes>java-Xms140M-Xmx140Mtune.MemoryHighDemo
  44. readtocreatebytes,sojvmheapwillbeused
  45. readtoallocate&putdirectbytebuffer,nojvmheapshouldbeused
  46. readytogc,jvmheapwillbefreed
  47. readtogetbytes,thenjvmheapwillbeused
  48. resultbytes[1]is:2
  49. readtogcall
  50. */

ObjectCachePool

[java]view plaincopy
  1. /**
  2. *
  3. */
  4. packagetune.program.memory;
  5. importjava.util.LinkedHashMap;
  6. importjava.util.Map;
  7. importjava.util.Set;
  8. /**
  9. *采用合理的缓存失效算法:FIFO、LRU、LFU等
  10. *
  11. *@authoryangwmAug24,20106:06:48PM
  12. */
  13. publicclassObjectCachePool<K,V>{
  14. publicstaticvoidmain(String[]args){
  15. //FIFO_POLICY
  16. intsize=10;
  17. intpolicy=1;
  18. ObjectCachePool<Integer,Integer>objectCachePool=newObjectCachePool<Integer,Integer>(size,policy);
  19. for(inti=1;i<=15;i++){
  20. objectCachePool.put(i,i);
  21. }
  22. for(inti=15;i>=1;i--){
  23. objectCachePool.put(i,i);
  24. }
  25. System.out.println("size("+size+"),policy("+policy+")FIFO");
  26. for(Map.Entry<Integer,Integer>entry:objectCachePool.entrySet()){
  27. System.out.println(entry.getKey()+","+entry.getValue());
  28. }
  30. //LRU_POLICY
  31. size=10;
  32. policy=2;
  33. objectCachePool=newObjectCachePool<Integer,Integer>(size,policy);
  34. for(inti=1;i<=15;i++){
  35. objectCachePool.put(i,i);
  36. }
  37. for(inti=15;i>=1;i--){
  38. objectCachePool.put(i,i);
  39. }
  40. System.out.println("size("+size+"),policy("+policy+")LRU");
  41. for(Map.Entry<Integer,Integer>entry:objectCachePool.entrySet()){
  42. System.out.println(entry.getKey()+","+entry.getValue());
  43. }
  44. }
  45. privatestaticfinalintFIFO_POLICY=1;
  46. privatestaticfinalintLRU_POLICY=2;
  47. privatestaticfinalintDEFAULT_SIZE=10;
  48. privateMap<K,V>cacheObjects;
  49. publicObjectCachePool(){
  50. this(DEFAULT_SIZE);
  51. }
  52. publicObjectCachePool(intsize){
  53. this(size,FIFO_POLICY);
  54. }
  55. publicObjectCachePool(finalintsize,finalintpolicy){
  56. switch(policy){
  58. caseFIFO_POLICY:
  59. cacheObjects=newLinkedHashMap<K,V>(size){
  60. /**
  61. *
  62. */
  63. privatestaticfinallongserialVersionUID=1L;
  64. protectedbooleanremoveEldestEntry(Map.Entry<K,V>eldest){
  65. returnsize()>size;
  66. }
  67. };
  68. break;
  69. caseLRU_POLICY:
  70. cacheObjects=newLinkedHashMap<K,V>(size,0.75f,true){
  71. /**
  72. *
  73. */
  74. privatestaticfinallongserialVersionUID=1L;
  75. protectedbooleanremoveEldestEntry(Map.Entry<K,V>eldest){
  76. returnsize()>size;
  77. }
  78. };
  79. break;
  80. default:
  81. thrownewIllegalArgumentException("Unknownpolicy:"+policy);
  82. }
  83. }
  84. publicvoidput(Kkey,Vvalue){
  85. cacheObjects.put(key,value);
  86. }
  87. publicvoidget(Kkey){
  88. cacheObjects.get(key);
  89. }
  90. publicvoidremove(Kkey){
  91. cacheObjects.remove(key);
  92. }
  93. publicvoidclear(){
  94. cacheObjects.clear();
  95. }
  97. publicSet<Map.Entry<K,V>>entrySet(){
  98. returncacheObjects.entrySet();
  99. }
  100. }
  101. /*
  102. size(10),policy(1)FIFO
  103. 11,11
  104. 12,12
  105. 13,13
  106. 14,14
  107. 15,15
  108. 5,5
  109. 4,4
  110. 3,3
  111. 2,2
  112. 1,1
  113. size(10),policy(2)LRU
  114. 10,10
  115. 9,9
  116. 8,8
  117. 7,7
  118. 6,6
  119. 5,5
  120. 4,4
  121. 3,3
  122. 2,2
  123. 1,1
  124. */

ObjectPoolDemo

[java]view plaincopy
  1. /**
  2. *
  3. */
  4. packagetune.program.memory;
  5. importjava.util.HashMap;
  6. importjava.util.Map;
  7. importjava.util.concurrent.CountDownLatch;
  8. /**
  9. *使用对象缓存池：创建对象要消耗一定的CPU以及内存，使用对象缓存池一定程度上可降低JVM堆内存的使用。
  10. *
  11. *@authoryangwmAug24,20104:34:47PM
  12. */
  13. publicclassObjectPoolDemo{
  14. privatestaticintexecuteTimes=10;
  15. privatestaticintmaxFactor=10;
  16. privatestaticintthreadCount=100;
  17. privatestaticfinalintNOTUSE_OBJECTPOOL=1;
  18. privatestaticfinalintUSE_OBJECTPOOL=2;
  19. privatestaticintrunMode=NOTUSE_OBJECTPOOL;
  20. privatestaticCountDownLatchlatch=null;
  21. publicstaticvoidmain(String[]args)throwsException{
  22. Tasktask=newTask();
  23. longbeginTime=System.currentTimeMillis();
  24. for(inti=0;i<executeTimes;i++){
  25. System.out.println("Round:"+(i+1));
  26. latch=newCountDownLatch(threadCount);
  27. for(intj=0;j<threadCount;j++){
  28. newThread(task).start();
  29. }
  30. latch.await();
  31. }
  32. longendTime=System.currentTimeMillis();
  33. System.out.println("Executesummary:Round("+executeTimes+")ThreadPerRound("+threadCount
  34. +")ObjectFactor("+maxFactor+")ExecuteTime("+(endTime-beginTime)+")ms");
  35. }
  37. staticclassTaskimplementsRunnable{
  38. @Override
  39. publicvoidrun(){
  40. for(intj=0;j<maxFactor;j++){
  41. if(runMode==USE_OBJECTPOOL){
  42. BigObjectPool.getInstance().getBigObject(j);
  43. }else{
  44. newBigObject(j);
  45. }
  46. }
  47. latch.countDown();
  48. }
  50. }
  52. staticclassBigObjectPool{
  53. privatestaticfinalBigObjectPoolself=newBigObjectPool();
  54. privatefinalMap<Integer,BigObject>cacheObjects=newHashMap<Integer,BigObject>();
  55. privateBigObjectPool(){
  57. }
  58. publicstaticBigObjectPoolgetInstance(){
  59. returnself;
  60. }
  61. publicBigObjectgetBigObject(intfactor){
  62. if(cacheObjects.containsKey(factor)){
  63. returncacheObjects.get(factor);
  64. }else{
  65. BigObjectobject=newBigObject(factor);
  66. cacheObjects.put(factor,object);
  67. returnobject;
  68. }
  69. }
  70. }
  72. staticclassBigObject{
  73. privatebyte[]bytes=null;
  74. publicBigObject(intfactor){
  75. bytes=newbyte[(factor+1)*1024*1024];
  76. }
  77. publicbyte[]getBytes(){
  78. returnbytes;
  79. }
  80. }
  82. }
  83. /*
  84. -Xms128M-Xmx128M-Xmn64M,runModeisNOTUSE_OBJECTPOOL:
  85. Round:1
  86. ......
  87. Executesummary:Round(10)ThreadPerRound(100)ObjectFactor(10)ExecuteTime(50672)ms
  88. -Xms128M-Xmx128M-Xmn64M,runModeisUSE_OBJECTPOOL:
  89. Round:1
  90. ......
  91. Executesummary:Round(10)ThreadPerRound(100)ObjectFactor(10)ExecuteTime(344)ms
  92. */

ThreadLocalDemo

[java]view plaincopy
  1. /**
  2. *
  3. */
  4. packagetune.program.memory;
  5. importjava.util.concurrent.ExecutorService;
  6. importjava.util.concurrent.Executors;
  7. /**
  8. *释放不必要的引用：代码持有了不需要的对象引用，造成这些对象无法被GC，从而占据了JVM堆内存。
  9. *（使用ThreadLocal：注意在线程内动作执行完毕时，需执行ThreadLocal.set把对象清除，避免持有不必要的对象引用）
  10. *
  11. *@authoryangwmAug24,201011:29:59AM
  12. */
  13. publicclassThreadLocalDemo{
  15. publicstaticvoidmain(String[]args){
  16. ThreadLocalDemodemo=newThreadLocalDemo();
  17. demo.run();
  18. }
  20. publicvoidrun(){
  21. ExecutorServiceexecutor=Executors.newFixedThreadPool(1);
  22. executor.execute(newTask());
  23. System.gc();
  24. }
  26. classTaskimplementsRunnable{
  27. @Override
  28. publicvoidrun(){
  29. ThreadLocal<byte[]>localString=newThreadLocal<byte[]>();
  30. localString.set(newbyte[1024*1024*30]);
  32. //业务逻辑
  34. //localString.set(null);//释放不必要的引用
  35. }
  36. }
  37. }

concurrent-----------------------------------------------------------------------

LockHotDemo

[java]view plaincopy
  1. /**
  2. *
  3. */
  4. packagetune.program.concurrent;
  5. importjava.util.Random;
  6. importjava.util.concurrent.CountDownLatch;
  7. importjava.util.concurrent.locks.Lock;
  8. importjava.util.concurrent.locks.ReentrantLock;
  9. /**
  10. *锁竞争的状况会比较明显，这时候线程很容易处于等待锁的状况，从而导致性能下降以及CPUsy上升
  11. *
  12. *@authoryangwmAug24,201011:59:35PM
  13. */
  14. publicclassLockHotDemo{
  15. privatestaticintexecuteTimes=10;
  16. privatestaticintthreadCount=Runtime.getRuntime().availableProcessors()*100;
  17. privatestaticCountDownLatchlatch=null;
  19. publicstaticvoidmain(String[]args)throwsException{
  20. HandleTasktask=newHandleTask();
  21. longbeginTime=System.currentTimeMillis();
  22. for(inti=0;i<executeTimes;i++){
  23. System.out.println("Round:"+(i+1));
  24. latch=newCountDownLatch(threadCount);
  25. for(intj=0;j<threadCount;j++){
  26. newThread(task).start();
  27. }
  28. latch.await();
  29. }
  30. longendTime=System.currentTimeMillis();
  31. System.out.println("Executesummary:Round("+executeTimes+")ThreadPerRound("+threadCount
  32. +")ExecuteTime("+(endTime-beginTime)+")ms");
  33. }
  35. staticclassHandleTaskimplementsRunnable{
  36. privatefinalRandomrandom=newRandom();
  37. @Override
  38. publicvoidrun(){
  39. Handler.getInstance().handle(random.nextInt(10000));
  40. latch.countDown();
  41. }
  43. }
  45. staticclassHandler{
  46. privatestaticfinalHandlerself=newHandler();
  47. privatefinalRandomrandom=newRandom();
  48. privatefinalLocklock=newReentrantLock();
  49. privateHandler(){
  51. }
  52. publicstaticHandlergetInstance(){
  53. returnself;
  54. }
  55. publicvoidhandle(intid){
  56. try{
  57. lock.lock();
  59. //executesth
  60. try{
  61. Thread.sleep(random.nextInt(10));
  62. }catch(Exceptione){
  63. e.printStackTrace();
  64. }
  65. }finally{
  66. lock.unlock();
  67. }
  68. }
  69. }
  70. }
  71. /*
  72. Round:1
  73. ......
  74. Round:10
  75. Executesummary:Round(10)ThreadPerRound(200)ExecuteTime(10625)ms
  76. */

ReduceLockHotDemo

[java]view plaincopy
  1. /**
  2. *
  3. */
  4. packagetune.program.concurrent;
  5. importjava.util.Random;
  6. importjava.util.concurrent.CountDownLatch;
  7. importjava.util.concurrent.locks.Lock;
  8. importjava.util.concurrent.locks.ReentrantLock;
  9. /**
  10. *尽可能少用锁：尽可能只对需要控制的资源做加锁操作
  11. *
  12. *@authoryangwmAug24,201011:59:35PM
  13. */
  14. publicclassReduceLockHotDemo{
  15. privatestaticintexecuteTimes=10;
  16. privatestaticintthreadCount=Runtime.getRuntime().availableProcessors()*100;
  17. privatestaticCountDownLatchlatch=null;
  19. publicstaticvoidmain(String[]args)throwsException{
  20. HandleTasktask=newHandleTask();
  21. longbeginTime=System.currentTimeMillis();
  22. for(inti=0;i<executeTimes;i++){
  23. System.out.println("Round:"+(i+1));
  24. latch=newCountDownLatch(threadCount);
  25. for(intj=0;j<threadCount;j++){
  26. newThread(task).start();
  27. }
  28. latch.await();
  29. }
  30. longendTime=System.currentTimeMillis();
  31. System.out.println("Executesummary:Round("+executeTimes+")ThreadPerRound("+threadCount
  32. +")ExecuteTime("+(endTime-beginTime)+")ms");
  33. }
  35. staticclassHandleTaskimplementsRunnable{
  36. privatefinalRandomrandom=newRandom();
  37. @Override
  38. publicvoidrun(){
  39. Handler.getInstance().handle(random.nextInt(10000));
  40. latch.countDown();
  41. }
  43. }
  45. staticclassHandler{
  46. privatestaticfinalHandlerself=newHandler();
  47. privatefinalRandomrandom=newRandom();
  48. privatefinalLocklock=newReentrantLock();
  49. privateHandler(){
  51. }
  52. publicstaticHandlergetInstance(){
  53. returnself;
  54. }
  55. publicvoidhandle(intid){
  56. //executesthdon'tneedlock
  57. try{
  58. Thread.sleep(random.nextInt(5));
  59. }catch(Exceptione){
  60. e.printStackTrace();
  61. }
  63. try{
  64. lock.lock();
  66. //executesth
  67. try{
  68. Thread.sleep(random.nextInt(5));
  69. }catch(Exceptione){
  70. e.printStackTrace();
  71. }
  72. }finally{
  73. lock.unlock();
  74. }
  75. }
  76. }
  77. }
  78. /*
  79. Round:1
  80. ......
  81. Round:10
  82. Executesummary:Round(10)ThreadPerRound(200)ExecuteTime(5547)ms
  83. */

SplitReduceLockHotDemo

[java]view plaincopy
  1. /**
  2. *
  3. */
  4. packagetune.program.concurrent;
  5. importjava.util.Random;
  6. importjava.util.concurrent.CountDownLatch;
  7. importjava.util.concurrent.locks.Lock;
  8. importjava.util.concurrent.locks.ReentrantLock;
  9. /**
  10. *尽可能少用锁：尽可能只对需要控制的资源做加锁操作
  11. *拆分锁：独占锁拆分为多把锁（读写锁拆分、类似ConcurrentHashMap中默认拆分为16把锁）
  12. *
  13. *@authoryangwmAug24,201011:59:35PM
  14. */
  15. publicclassSplitReduceLockHotDemo{
  16. privatestaticintexecuteTimes=10;
  17. privatestaticintthreadCount=Runtime.getRuntime().availableProcessors()*100;
  18. privatestaticCountDownLatchlatch=null;
  20. publicstaticvoidmain(String[]args)throwsException{
  21. HandleTasktask=newHandleTask();
  22. longbeginTime=System.currentTimeMillis();
  23. for(inti=0;i<executeTimes;i++){
  24. System.out.println("Round:"+(i+1));
  25. latch=newCountDownLatch(threadCount);
  26. for(intj=0;j<threadCount;j++){
  27. newThread(task).start();
  28. }
  29. latch.await();
  30. }
  31. longendTime=System.currentTimeMillis();
  32. System.out.println("Executesummary:Round("+executeTimes+")ThreadPerRound("+threadCount
  33. +")ExecuteTime("+(endTime-beginTime)+")ms");
  34. }
  36. staticclassHandleTaskimplementsRunnable{
  37. privatefinalRandomrandom=newRandom();
  38. @Override
  39. publicvoidrun(){
  40. Handler.getInstance().handle(random.nextInt(10000));
  41. latch.countDown();
  42. }
  44. }
  46. staticclassHandler{
  47. privatestaticfinalHandlerself=newHandler();
  48. privatefinalRandomrandom=newRandom();
  49. privateintlockCount=10;
  50. privateLock[]locks=newLock[lockCount];
  51. privateHandler(){
  52. for(inti=0;i<lockCount;i++){
  53. locks[i]=newReentrantLock();
  54. }
  55. }
  56. publicstaticHandlergetInstance(){
  57. returnself;
  58. }
  59. publicvoidhandle(intid){
  60. //executesthdon'tneedlock
  61. try{
  62. Thread.sleep(random.nextInt(5));
  63. }catch(Exceptione){
  64. e.printStackTrace();
  65. }
  67. intmod=id%lockCount;
  68. try{
  69. locks[mod].lock();
  71. //executesth
  72. try{
  73. Thread.sleep(random.nextInt(5));
  74. }catch(Exceptione){
  75. e.printStackTrace();
  76. }
  77. }finally{
  78. locks[mod].unlock();
  79. }
  80. }
  81. }
  82. }
  83. /*
  84. Round:1
  85. ......
  86. Round:10
  87. Executesummary:Round(10)ThreadPerRound(200)ExecuteTime(843)ms
  88. */

ConcurrentStack和StackBenchmark

[java]view plaincopy
  1. /**
  2. *
  3. */
  4. packagetune.program.concurrent;
  5. importjava.util.concurrent.atomic.AtomicReference;
  6. /**
  7. *使用Treiber算法实现Stack：基于CAS以及AtomicReference。
  8. *
  9. *@authoryangwmAug25,201010:50:17AM
  10. */
  11. publicclassConcurrentStack<E>{
  13. AtomicReference<Node<E>>head=newAtomicReference<Node<E>>();
  14. publicvoidpush(Eitem){
  15. Node<E>newHead=newNode<E>(item);
  16. Node<E>oldHead;
  17. do{
  18. oldHead=head.get();
  19. newHead.next=oldHead;
  20. }while(!head.compareAndSet(oldHead,newHead));
  21. }
  23. publicEpop(){
  24. Node<E>oldHead;
  25. Node<E>newHead;
  26. do{
  27. oldHead=head.get();
  28. if(oldHead==null){
  29. returnnull;
  30. }
  31. newHead=oldHead.next;
  32. }while(!head.compareAndSet(oldHead,newHead));
  33. returnoldHead.item;
  34. }
  36. staticclassNode<E>{
  37. finalEitem;
  38. Node<E>next;
  39. publicNode(Eitem){
  40. this.item=item;
  41. }
  42. }
  43. }
  44. /**
  45. *
  46. */
  47. packagetune.program.concurrent;
  48. importjava.util.Stack;
  49. importjava.util.concurrent.CountDownLatch;
  50. importjava.util.concurrent.CyclicBarrier;
  51. /**
  52. *基准测试：Treiber算法实现Stack、同步实现的Stack
  53. *
  54. *@authoryangwmAug25,201011:36:14AM
  55. */
  56. publicclassStackBenchmark{
  57. publicstaticvoidmain(String[]args)throwsException{
  58. StackBenchmarkstackBenchmark=newStackBenchmark();
  59. stackBenchmark.run();
  60. }
  63. privateStack<String>stack=newStack<String>();
  64. privateConcurrentStack<String>concurrentStack=newConcurrentStack<String>();
  65. privatestaticfinalintTHREAD_COUNT=300;
  66. privateCountDownLatchlatch=newCountDownLatch(THREAD_COUNT);
  67. privateCyclicBarrierbarrier=newCyclicBarrier(THREAD_COUNT);
  69. publicvoidrun()throwsException{
  70. StackTaskstackTask=newStackTask();
  71. longbeginTime=System.currentTimeMillis();
  72. for(inti=0;i<THREAD_COUNT;i++){
  73. newThread(stackTask).start();
  74. }
  75. latch.await();
  76. longendTime=System.currentTimeMillis();
  77. System.out.println("StackconsumeTime:"+(endTime-beginTime)+"ms");
  79. latch=newCountDownLatch(THREAD_COUNT);
  80. barrier=newCyclicBarrier(THREAD_COUNT);
  81. ConcurrentStackTaskconcurrentStackTask=newConcurrentStackTask();
  82. beginTime=System.currentTimeMillis();
  83. for(inti=0;i<THREAD_COUNT;i++){
  84. newThread(concurrentStackTask).start();
  85. }
  86. latch.await();
  87. endTime=System.currentTimeMillis();
  88. System.out.println("ConcurrentStackconsumeTime:"+(endTime-beginTime)+"ms");
  89. }
  91. classStackTaskimplementsRunnable{
  93. @Override
  94. publicvoidrun(){
  95. try{
  96. barrier.await();
  97. }catch(Exceptione){
  98. e.printStackTrace();
  99. }
  100. for(inti=0;i<10;i++){
  101. stack.push(Thread.currentThread().getName());
  102. stack.pop();
  103. }
  104. latch.countDown();
  105. }
  107. }
  108. classConcurrentStackTaskimplementsRunnable{
  110. @Override
  111. publicvoidrun(){
  112. try{
  113. barrier.await();
  114. }catch(Exceptione){
  115. e.printStackTrace();
  116. }
  117. for(inti=0;i<10;i++){
  118. concurrentStack.push(Thread.currentThread().getName());
  119. concurrentStack.pop();
  120. }
  121. latch.countDown();
  122. }
  124. }
  126. }
  127. /*
  128. StackconsumeTime:94ms
  129. ConcurrentStackconsumeTime:63ms
  130. StackconsumeTime:78ms
  131. ConcurrentStackconsumeTime:62ms
  132. */

分享到：
| JVM调优
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

Magicbox
Global site tag (gtag.js) - Google Analytics