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

/**
*
*/
packagetune.program.cpu;
importjava.util.ArrayList;
importjava.util.List;
importjava.util.Random;
/**
*未充分利用CPU：在能并行处理的场景中未使用足够的线程（线程增加：CPU资源消耗可接受且不会带来激烈竞争锁的场景下）
*
*@authoryangwmAug25,20109:54:50AM
*/
publicclassCpuNotUseEffectiveDemo{

privatestaticintexecuteTimes=10;
privatestaticinttaskCount=200;

publicstaticvoidmain(String[]args)throwsException{
Tasktask=newTask();
for(inti=0;i<taskCount;i++){
task.addTask(Integer.toString(i));
}

longbeginTime=System.currentTimeMillis();
for(inti=0;i<executeTimes;i++){
System.out.println("Round:"+(i+1));
Threadthread=newThread(task);
thread.start();
thread.join();
}
longendTime=System.currentTimeMillis();
System.out.println("Executesummary:Round("+executeTimes+")TaskCountPerRound("+taskCount
+")ExecuteTime("+(endTime-beginTime)+")ms");
}

staticclassTaskimplementsRunnable{
List<String>tasks=newArrayList<String>();
Randomrandom=newRandom();
booleanexitFlag=false;

publicvoidaddTask(Stringtask){
List<String>copyTasks=newArrayList<String>(tasks);
copyTasks.add(task);

tasks=copyTasks;
}
@Override
publicvoidrun(){
List<String>runTasks=tasks;
List<String>removeTasks=newArrayList<String>();
for(Stringtask:runTasks){
try{
Thread.sleep(random.nextInt(10));
}catch(Exceptione){
e.printStackTrace();
}

removeTasks.add(task);
}

try{
Thread.sleep(10);
}catch(Exceptione){
e.printStackTrace();
}
}

}

}
/*
Round:1
......
Round:10
Executesummary:Round(10)TaskCountPerRound(200)ExecuteTime(10687)ms
*/

CpuUseEffectiveDemo

/**
*
*/
packagetune.program.cpu;
importjava.util.ArrayList;
importjava.util.List;
importjava.util.Random;
importjava.util.concurrent.CountDownLatch;

/**
*充分利用CPU：在能并行处理的场景中使用足够的线程（线程增加：CPU资源消耗可接受且不会带来激烈竞争锁的场景下）
*
*@authoryangwmAug25,20109:54:50AM
*/
publicclassCpuUseEffectiveDemo{

privatestaticintexecuteTimes=10;
privatestaticinttaskCount=200;
privatestaticfinalintTASK_THREADCOUNT=16;
privatestaticCountDownLatchlatch;

publicstaticvoidmain(String[]args)throwsException{
Task[]tasks=newTask[TASK_THREADCOUNT];
for(inti=0;i<TASK_THREADCOUNT;i++){
tasks[i]=newTask();
}
for(inti=0;i<taskCount;i++){
intmod=i%TASK_THREADCOUNT;
tasks[mod].addTask(Integer.toString(i));
}

longbeginTime=System.currentTimeMillis();
for(inti=0;i<executeTimes;i++){
System.out.println("Round:"+(i+1));
latch=newCountDownLatch(TASK_THREADCOUNT);
for(intj=0;j<TASK_THREADCOUNT;j++){
Threadthread=newThread(tasks[j]);
thread.start();
}
latch.await();
}
longendTime=System.currentTimeMillis();
System.out.println("Executesummary:Round("+executeTimes+")TaskCountPerRound("+taskCount
+")ExecuteTime("+(endTime-beginTime)+")ms");
}

staticclassTaskimplementsRunnable{
List<String>tasks=newArrayList<String>();
Randomrandom=newRandom();
booleanexitFlag=false;

publicvoidaddTask(Stringtask){
List<String>copyTasks=newArrayList<String>(tasks);
copyTasks.add(task);

tasks=copyTasks;
}
@Override
publicvoidrun(){
List<String>runTasks=tasks;
List<String>removeTasks=newArrayList<String>();
for(Stringtask:runTasks){
try{
Thread.sleep(random.nextInt(10));
}catch(Exceptione){
e.printStackTrace();
}

removeTasks.add(task);
}

try{
Thread.sleep(10);
}catch(Exceptione){
e.printStackTrace();
}
latch.countDown();
}

}

}
/*
Round:1
......
Round:10
Executesummary:Round(10)TaskCountPerRound(200)ExecuteTime(938)ms
*/

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

IOWaitHighDemo

/**
*
*/
packagetune.program.fileio;
importjava.io.BufferedWriter;
importjava.io.File;
importjava.io.FileWriter;
importjava.util.Random;
/**
*文件IO消耗严重的原因主要是多个线程在写进行大量的数据到同一文件，
*导致文件很快变得很大，从而写入速度越来越慢，并造成各线程激烈争抢文件锁。
*
*@authoryangwmAug21,20109:48:34PM
*/
publicclassIOWaitHighDemo{
privateStringfileName="iowait.log";

privatestaticintthreadCount=Runtime.getRuntime().availableProcessors();

privateRandomrandom=newRandom();

publicstaticvoidmain(String[]args)throwsException{
if(args.length==1){
threadCount=Integer.parseInt(args[1]);
}

IOWaitHighDemodemo=newIOWaitHighDemo();
demo.runTest();
}

privatevoidrunTest()throwsException{
Filefile=newFile(fileName);
file.createNewFile();

for(inti=0;i<threadCount;i++){
newThread(newTask()).start();
}

}

classTaskimplementsRunnable{
@Override
publicvoidrun(){
while(true){
try{
StringBuilderstrBuilder=newStringBuilder("====begin====/n");
StringthreadName=Thread.currentThread().getName();
for(inti=0;i<100000;i++){
strBuilder.append(threadName);
strBuilder.append("/n");
}
strBuilder.append("====end====/n");

BufferedWriterwriter=newBufferedWriter(newFileWriter(fileName,true));
writer.write(strBuilder.toString());
writer.close();
Thread.sleep(random.nextInt(10));
}catch(Exceptione){

}
}
}

}

}
/*
C:/DocumentsandSettings/yangwm>jstack2656
2010-08-2123:24:17
FullthreaddumpJavaHotSpot(TM)ClientVM(17.0-b05mixedmode):
"DestroyJavaVM"prio=6tid=0x00868c00nid=0xde0waitingoncondition[0x00000000]
java.lang.Thread.State:RUNNABLE
"Thread-1"prio=6tid=0x0ab9dc00nid=0xb7crunnable[0x0b0bf000]
java.lang.Thread.State:RUNNABLE
atjava.io.FileOutputStream.close0(NativeMethod)
atjava.io.FileOutputStream.close(FileOutputStream.java:336)
atsun.nio.cs.StreamEncoder.implClose(StreamEncoder.java:320)
atsun.nio.cs.StreamEncoder.close(StreamEncoder.java:149)
-locked<0x034dd268>(ajava.io.FileWriter)
atjava.io.OutputStreamWriter.close(OutputStreamWriter.java:233)
atjava.io.BufferedWriter.close(BufferedWriter.java:265)
-locked<0x034dd268>(ajava.io.FileWriter)
attune.IOWaitHighDemo$Task.run(IOWaitHighDemo.java:58)
atjava.lang.Thread.run(Thread.java:717)
"Thread-0"prio=6tid=0x0ab9d400nid=0x80crunnable[0x0b06f000]
java.lang.Thread.State:RUNNABLE
atjava.io.FileOutputStream.writeBytes(NativeMethod)
atjava.io.FileOutputStream.write(FileOutputStream.java:292)
atsun.nio.cs.StreamEncoder.writeBytes(StreamEncoder.java:221)
atsun.nio.cs.StreamEncoder.implWrite(StreamEncoder.java:282)
atsun.nio.cs.StreamEncoder.write(StreamEncoder.java:125)
-locked<0x034e1290>(ajava.io.FileWriter)
atjava.io.OutputStreamWriter.write(OutputStreamWriter.java:207)
atjava.io.BufferedWriter.flushBuffer(BufferedWriter.java:128)
-locked<0x034e1290>(ajava.io.FileWriter)
atjava.io.BufferedWriter.write(BufferedWriter.java:229)
-locked<0x034e1290>(ajava.io.FileWriter)
atjava.io.Writer.write(Writer.java:157)
attune.IOWaitHighDemo$Task.run(IOWaitHighDemo.java:57)
atjava.lang.Thread.run(Thread.java:717)
"LowMemoryDetector"daemonprio=6tid=0x0ab6f800nid=0xfb0runnable[0x00000000]
java.lang.Thread.State:RUNNABLE
"CompilerThread0"daemonprio=10tid=0x0ab6c800nid=0x5fcwaitingoncondition[0x00000000]
java.lang.Thread.State:RUNNABLE
"AttachListener"daemonprio=10tid=0x0ab67800nid=0x6fcwaitingoncondition[0x00000000]
java.lang.Thread.State:RUNNABLE
"SignalDispatcher"daemonprio=10tid=0x0ab66800nid=0x5a0runnable[0x00000000]
java.lang.Thread.State:RUNNABLE
"Finalizer"daemonprio=8tid=0x0ab54000nid=0xe74inObject.wait()[0x0ac8f000]
java.lang.Thread.State:WAITING(onobjectmonitor)
atjava.lang.Object.wait(NativeMethod)
-waitingon<0x02f15d90>(ajava.lang.ref.ReferenceQueue$Lock)
atjava.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:135)
-locked<0x02f15d90>(ajava.lang.ref.ReferenceQueue$Lock)
atjava.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:151)
atjava.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:177)
"ReferenceHandler"daemonprio=10tid=0x0ab4f800nid=0x8a4inObject.wait()[0x0ac3f000]
java.lang.Thread.State:WAITING(onobjectmonitor)
atjava.lang.Object.wait(NativeMethod)
-waitingon<0x02f15af8>(ajava.lang.ref.Reference$Lock)
atjava.lang.Object.wait(Object.java:502)
atjava.lang.ref.Reference$ReferenceHandler.run(Reference.java:133)
-locked<0x02f15af8>(ajava.lang.ref.Reference$Lock)
"VMThread"prio=10tid=0x0ab4a800nid=0x1d0runnable
"VMPeriodicTaskThread"prio=10tid=0x0ab7d400nid=0x464waitingoncondition
JNIglobalreferences:693

C:/DocumentsandSettings/yangwm>
*/

LogControl

/**
*
*/
packagetune.program.fileio;
importjava.util.concurrent.atomic.AtomicInteger;
/**
*日志控制：采用简单策略为统计一段时间内日志输出频率，当超出这个频率时，一段时间内不再写log
*
*@authoryangwmAug24,201010:41:43AM
*/
publicclassLogControl{

publicstaticvoidmain(String[]args){
for(inti=1;i<=1000;i++){
if(LogControl.isLog()){
//logger.error(errorInfo,throwable);
System.out.println("errorInfo"+i);
}

//
if(i%100==0){
try{
Thread.sleep(1000);
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
}
}


privatestaticfinallongINTERVAL=1000;
privatestaticfinallongPUNISH_TIME=5000;
privatestaticfinalintERROR_THRESHOLD=100;
privatestaticAtomicIntegercount=newAtomicInteger(0);
privatestaticlongbeginTime;
privatestaticlongpunishTimeEnd;

//由于控制不用非常精确，因此忽略此处的并发问题
publicstaticbooleanisLog(){
//System.out.println(count.get()+","+beginTime+","+punishTimeEnd+","+System.currentTimeMillis());

//不写日志阶段
if(punishTimeEnd>0&&punishTimeEnd>System.currentTimeMillis()){
returnfalse;
}

//重新计数
if(count.getAndIncrement()==0){
beginTime=System.currentTimeMillis();
returntrue;
}else{//已在计数
//超过阀门值，设置count为0并设置一段时间内不写日志
if(count.get()>ERROR_THRESHOLD){
count.set(0);
punishTimeEnd=PUNISH_TIME+System.currentTimeMillis();
returnfalse;
}
//没超过阀门值，且当前时间已超过计数周期，则重新计算
elseif(System.currentTimeMillis()>(beginTime+INTERVAL)){
count.set(0);
}

returntrue;
}
}

}
/*
errorInfo1
errorInfo2
......
errorInfo99
errorInfo100
errorInfo601
errorInfo602
......
errorInfo699
errorInfo700
*/

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

MemoryHighDemo

/**
*
*/
packagetune.program.memory;
importjava.nio.ByteBuffer;
/**
*directbytebuffer消耗的是jvm堆外的内存，但同样是基于GC方式来释放的。
*
*@authoryangwmAug21,20109:40:18PM
*/
publicclassMemoryHighDemo{

publicstaticvoidmain(String[]args)throwsException{
Thread.sleep(20000);
System.out.println("readtocreatebytes,sojvmheapwillbeused");
byte[]bytes=newbyte[128*1000*1000];
bytes[0]=1;
bytes[1]=2;
Thread.sleep(10000);
System.out.println("readtoallocate&putdirectbytebuffer,nojvmheapshouldbeused");
ByteBufferbuffer=ByteBuffer.allocateDirect(128*1024*1024);
buffer.put(bytes);
buffer.flip();
Thread.sleep(10000);
System.out.println("readytogc,jvmheapwillbefreed");
bytes=null;
System.gc();
Thread.sleep(10000);
System.out.println("readtogetbytes,thenjvmheapwillbeused");
byte[]resultbytes=newbyte[128*1000*1000];
buffer.get(resultbytes);
System.out.println("resultbytes[1]is:"+resultbytes[1]);
Thread.sleep(10000);
System.out.println("readtogcall");
buffer=null;
resultbytes=null;
System.gc();
Thread.sleep(10000);
}

}
/*
D:/study/tempProject/JavaLearn/classes>java-Xms140M-Xmx140Mtune.MemoryHighDemo
readtocreatebytes,sojvmheapwillbeused
readtoallocate&putdirectbytebuffer,nojvmheapshouldbeused
readytogc,jvmheapwillbefreed
readtogetbytes,thenjvmheapwillbeused
resultbytes[1]is:2
readtogcall
*/

ObjectCachePool

/**
*
*/
packagetune.program.memory;
importjava.util.LinkedHashMap;
importjava.util.Map;
importjava.util.Set;
/**
*采用合理的缓存失效算法:FIFO、LRU、LFU等
*
*@authoryangwmAug24,20106:06:48PM
*/
publicclassObjectCachePool<K,V>{
publicstaticvoidmain(String[]args){
//FIFO_POLICY
intsize=10;
intpolicy=1;
ObjectCachePool<Integer,Integer>objectCachePool=newObjectCachePool<Integer,Integer>(size,policy);
for(inti=1;i<=15;i++){
objectCachePool.put(i,i);
}
for(inti=15;i>=1;i--){
objectCachePool.put(i,i);
}
System.out.println("size("+size+"),policy("+policy+")FIFO");
for(Map.Entry<Integer,Integer>entry:objectCachePool.entrySet()){
System.out.println(entry.getKey()+","+entry.getValue());
}

//LRU_POLICY
size=10;
policy=2;
objectCachePool=newObjectCachePool<Integer,Integer>(size,policy);
for(inti=1;i<=15;i++){
objectCachePool.put(i,i);
}
for(inti=15;i>=1;i--){
objectCachePool.put(i,i);
}
System.out.println("size("+size+"),policy("+policy+")LRU");
for(Map.Entry<Integer,Integer>entry:objectCachePool.entrySet()){
System.out.println(entry.getKey()+","+entry.getValue());
}
}
privatestaticfinalintFIFO_POLICY=1;
privatestaticfinalintLRU_POLICY=2;
privatestaticfinalintDEFAULT_SIZE=10;
privateMap<K,V>cacheObjects;
publicObjectCachePool(){
this(DEFAULT_SIZE);
}
publicObjectCachePool(intsize){
this(size,FIFO_POLICY);
}
publicObjectCachePool(finalintsize,finalintpolicy){
switch(policy){

caseFIFO_POLICY:
cacheObjects=newLinkedHashMap<K,V>(size){
/**
*
*/
privatestaticfinallongserialVersionUID=1L;
protectedbooleanremoveEldestEntry(Map.Entry<K,V>eldest){
returnsize()>size;
}
};
break;
caseLRU_POLICY:
cacheObjects=newLinkedHashMap<K,V>(size,0.75f,true){
/**
*
*/
privatestaticfinallongserialVersionUID=1L;
protectedbooleanremoveEldestEntry(Map.Entry<K,V>eldest){
returnsize()>size;
}
};
break;
default:
thrownewIllegalArgumentException("Unknownpolicy:"+policy);
}
}
publicvoidput(Kkey,Vvalue){
cacheObjects.put(key,value);
}
publicvoidget(Kkey){
cacheObjects.get(key);
}
publicvoidremove(Kkey){
cacheObjects.remove(key);
}
publicvoidclear(){
cacheObjects.clear();
}

publicSet<Map.Entry<K,V>>entrySet(){
returncacheObjects.entrySet();
}
}
/*
size(10),policy(1)FIFO
11,11
12,12
13,13
14,14
15,15
5,5
4,4
3,3
2,2
1,1
size(10),policy(2)LRU
10,10
9,9
8,8
7,7
6,6
5,5
4,4
3,3
2,2
1,1
*/

ObjectPoolDemo

/**
*
*/
packagetune.program.memory;
importjava.util.HashMap;
importjava.util.Map;
importjava.util.concurrent.CountDownLatch;
/**
*使用对象缓存池：创建对象要消耗一定的CPU以及内存，使用对象缓存池一定程度上可降低JVM堆内存的使用。
*
*@authoryangwmAug24,20104:34:47PM
*/
publicclassObjectPoolDemo{
privatestaticintexecuteTimes=10;
privatestaticintmaxFactor=10;
privatestaticintthreadCount=100;
privatestaticfinalintNOTUSE_OBJECTPOOL=1;
privatestaticfinalintUSE_OBJECTPOOL=2;
privatestaticintrunMode=NOTUSE_OBJECTPOOL;
privatestaticCountDownLatchlatch=null;
publicstaticvoidmain(String[]args)throwsException{
Tasktask=newTask();
longbeginTime=System.currentTimeMillis();
for(inti=0;i<executeTimes;i++){
System.out.println("Round:"+(i+1));
latch=newCountDownLatch(threadCount);
for(intj=0;j<threadCount;j++){
newThread(task).start();
}
latch.await();
}
longendTime=System.currentTimeMillis();
System.out.println("Executesummary:Round("+executeTimes+")ThreadPerRound("+threadCount
+")ObjectFactor("+maxFactor+")ExecuteTime("+(endTime-beginTime)+")ms");
}

staticclassTaskimplementsRunnable{
@Override
publicvoidrun(){
for(intj=0;j<maxFactor;j++){
if(runMode==USE_OBJECTPOOL){
BigObjectPool.getInstance().getBigObject(j);
}else{
newBigObject(j);
}
}
latch.countDown();
}

}

staticclassBigObjectPool{
privatestaticfinalBigObjectPoolself=newBigObjectPool();
privatefinalMap<Integer,BigObject>cacheObjects=newHashMap<Integer,BigObject>();
privateBigObjectPool(){

}
publicstaticBigObjectPoolgetInstance(){
returnself;
}
publicBigObjectgetBigObject(intfactor){
if(cacheObjects.containsKey(factor)){
returncacheObjects.get(factor);
}else{
BigObjectobject=newBigObject(factor);
cacheObjects.put(factor,object);
returnobject;
}
}
}

staticclassBigObject{
privatebyte[]bytes=null;
publicBigObject(intfactor){
bytes=newbyte[(factor+1)*1024*1024];
}
publicbyte[]getBytes(){
returnbytes;
}
}

}
/*
-Xms128M-Xmx128M-Xmn64M,runModeisNOTUSE_OBJECTPOOL:
Round:1
......
Executesummary:Round(10)ThreadPerRound(100)ObjectFactor(10)ExecuteTime(50672)ms
-Xms128M-Xmx128M-Xmn64M,runModeisUSE_OBJECTPOOL:
Round:1
......
Executesummary:Round(10)ThreadPerRound(100)ObjectFactor(10)ExecuteTime(344)ms
*/

ThreadLocalDemo

/**
*
*/
packagetune.program.memory;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.Executors;
/**
*释放不必要的引用：代码持有了不需要的对象引用，造成这些对象无法被GC，从而占据了JVM堆内存。
*（使用ThreadLocal：注意在线程内动作执行完毕时，需执行ThreadLocal.set把对象清除，避免持有不必要的对象引用）
*
*@authoryangwmAug24,201011:29:59AM
*/
publicclassThreadLocalDemo{

publicstaticvoidmain(String[]args){
ThreadLocalDemodemo=newThreadLocalDemo();
demo.run();
}

publicvoidrun(){
ExecutorServiceexecutor=Executors.newFixedThreadPool(1);
executor.execute(newTask());
System.gc();
}

classTaskimplementsRunnable{
@Override
publicvoidrun(){
ThreadLocal<byte[]>localString=newThreadLocal<byte[]>();
localString.set(newbyte[1024*1024*30]);

//业务逻辑

//localString.set(null);//释放不必要的引用
}
}
}

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

LockHotDemo

/**
*
*/
packagetune.program.concurrent;
importjava.util.Random;
importjava.util.concurrent.CountDownLatch;
importjava.util.concurrent.locks.Lock;
importjava.util.concurrent.locks.ReentrantLock;
/**
*锁竞争的状况会比较明显，这时候线程很容易处于等待锁的状况，从而导致性能下降以及CPUsy上升
*
*@authoryangwmAug24,201011:59:35PM
*/
publicclassLockHotDemo{
privatestaticintexecuteTimes=10;
privatestaticintthreadCount=Runtime.getRuntime().availableProcessors()*100;
privatestaticCountDownLatchlatch=null;

publicstaticvoidmain(String[]args)throwsException{
HandleTasktask=newHandleTask();
longbeginTime=System.currentTimeMillis();
for(inti=0;i<executeTimes;i++){
System.out.println("Round:"+(i+1));
latch=newCountDownLatch(threadCount);
for(intj=0;j<threadCount;j++){
newThread(task).start();
}
latch.await();
}
longendTime=System.currentTimeMillis();
System.out.println("Executesummary:Round("+executeTimes+")ThreadPerRound("+threadCount
+")ExecuteTime("+(endTime-beginTime)+")ms");
}

staticclassHandleTaskimplementsRunnable{
privatefinalRandomrandom=newRandom();
@Override
publicvoidrun(){
Handler.getInstance().handle(random.nextInt(10000));
latch.countDown();
}

}

staticclassHandler{
privatestaticfinalHandlerself=newHandler();
privatefinalRandomrandom=newRandom();
privatefinalLocklock=newReentrantLock();
privateHandler(){

}
publicstaticHandlergetInstance(){
returnself;
}
publicvoidhandle(intid){
try{
lock.lock();

//executesth
try{
Thread.sleep(random.nextInt(10));
}catch(Exceptione){
e.printStackTrace();
}
}finally{
lock.unlock();
}
}
}
}
/*
Round:1
......
Round:10
Executesummary:Round(10)ThreadPerRound(200)ExecuteTime(10625)ms
*/

ReduceLockHotDemo

/**
*
*/
packagetune.program.concurrent;
importjava.util.Random;
importjava.util.concurrent.CountDownLatch;
importjava.util.concurrent.locks.Lock;
importjava.util.concurrent.locks.ReentrantLock;
/**
*尽可能少用锁：尽可能只对需要控制的资源做加锁操作
*
*@authoryangwmAug24,201011:59:35PM
*/
publicclassReduceLockHotDemo{
privatestaticintexecuteTimes=10;
privatestaticintthreadCount=Runtime.getRuntime().availableProcessors()*100;
privatestaticCountDownLatchlatch=null;

publicstaticvoidmain(String[]args)throwsException{
HandleTasktask=newHandleTask();
longbeginTime=System.currentTimeMillis();
for(inti=0;i<executeTimes;i++){
System.out.println("Round:"+(i+1));
latch=newCountDownLatch(threadCount);
for(intj=0;j<threadCount;j++){
newThread(task).start();
}
latch.await();
}
longendTime=System.currentTimeMillis();
System.out.println("Executesummary:Round("+executeTimes+")ThreadPerRound("+threadCount
+")ExecuteTime("+(endTime-beginTime)+")ms");
}

staticclassHandleTaskimplementsRunnable{
privatefinalRandomrandom=newRandom();
@Override
publicvoidrun(){
Handler.getInstance().handle(random.nextInt(10000));
latch.countDown();
}

}

staticclassHandler{
privatestaticfinalHandlerself=newHandler();
privatefinalRandomrandom=newRandom();
privatefinalLocklock=newReentrantLock();
privateHandler(){

}
publicstaticHandlergetInstance(){
returnself;
}
publicvoidhandle(intid){
//executesthdon'tneedlock
try{
Thread.sleep(random.nextInt(5));
}catch(Exceptione){
e.printStackTrace();
}

try{
lock.lock();

//executesth
try{
Thread.sleep(random.nextInt(5));
}catch(Exceptione){
e.printStackTrace();
}
}finally{
lock.unlock();
}
}
}
}
/*
Round:1
......
Round:10
Executesummary:Round(10)ThreadPerRound(200)ExecuteTime(5547)ms
*/

SplitReduceLockHotDemo

/**
*
*/
packagetune.program.concurrent;
importjava.util.Random;
importjava.util.concurrent.CountDownLatch;
importjava.util.concurrent.locks.Lock;
importjava.util.concurrent.locks.ReentrantLock;
/**
*尽可能少用锁：尽可能只对需要控制的资源做加锁操作
*拆分锁：独占锁拆分为多把锁（读写锁拆分、类似ConcurrentHashMap中默认拆分为16把锁）
*
*@authoryangwmAug24,201011:59:35PM
*/
publicclassSplitReduceLockHotDemo{
privatestaticintexecuteTimes=10;
privatestaticintthreadCount=Runtime.getRuntime().availableProcessors()*100;
privatestaticCountDownLatchlatch=null;

publicstaticvoidmain(String[]args)throwsException{
HandleTasktask=newHandleTask();
longbeginTime=System.currentTimeMillis();
for(inti=0;i<executeTimes;i++){
System.out.println("Round:"+(i+1));
latch=newCountDownLatch(threadCount);
for(intj=0;j<threadCount;j++){
newThread(task).start();
}
latch.await();
}
longendTime=System.currentTimeMillis();
System.out.println("Executesummary:Round("+executeTimes+")ThreadPerRound("+threadCount
+")ExecuteTime("+(endTime-beginTime)+")ms");
}

staticclassHandleTaskimplementsRunnable{
privatefinalRandomrandom=newRandom();
@Override
publicvoidrun(){
Handler.getInstance().handle(random.nextInt(10000));
latch.countDown();
}

}

staticclassHandler{
privatestaticfinalHandlerself=newHandler();
privatefinalRandomrandom=newRandom();
privateintlockCount=10;
privateLock[]locks=newLock[lockCount];
privateHandler(){
for(inti=0;i<lockCount;i++){
locks[i]=newReentrantLock();
}
}
publicstaticHandlergetInstance(){
returnself;
}
publicvoidhandle(intid){
//executesthdon'tneedlock
try{
Thread.sleep(random.nextInt(5));
}catch(Exceptione){
e.printStackTrace();
}

intmod=id%lockCount;
try{
locks[mod].lock();

//executesth
try{
Thread.sleep(random.nextInt(5));
}catch(Exceptione){
e.printStackTrace();
}
}finally{
locks[mod].unlock();
}
}
}
}
/*
Round:1
......
Round:10
Executesummary:Round(10)ThreadPerRound(200)ExecuteTime(843)ms
*/

ConcurrentStack和StackBenchmark

/**
*
*/
packagetune.program.concurrent;
importjava.util.concurrent.atomic.AtomicReference;
/**
*使用Treiber算法实现Stack：基于CAS以及AtomicReference。
*
*@authoryangwmAug25,201010:50:17AM
*/
publicclassConcurrentStack<E>{

AtomicReference<Node<E>>head=newAtomicReference<Node<E>>();
publicvoidpush(Eitem){
Node<E>newHead=newNode<E>(item);
Node<E>oldHead;
do{
oldHead=head.get();
newHead.next=oldHead;
}while(!head.compareAndSet(oldHead,newHead));
}

publicEpop(){
Node<E>oldHead;
Node<E>newHead;
do{
oldHead=head.get();
if(oldHead==null){
returnnull;
}
newHead=oldHead.next;
}while(!head.compareAndSet(oldHead,newHead));
returnoldHead.item;
}

staticclassNode<E>{
finalEitem;
Node<E>next;
publicNode(Eitem){
this.item=item;
}
}
}
/**
*
*/
packagetune.program.concurrent;
importjava.util.Stack;
importjava.util.concurrent.CountDownLatch;
importjava.util.concurrent.CyclicBarrier;
/**
*基准测试：Treiber算法实现Stack、同步实现的Stack
*
*@authoryangwmAug25,201011:36:14AM
*/
publicclassStackBenchmark{
publicstaticvoidmain(String[]args)throwsException{
StackBenchmarkstackBenchmark=newStackBenchmark();
stackBenchmark.run();
}


privateStack<String>stack=newStack<String>();
privateConcurrentStack<String>concurrentStack=newConcurrentStack<String>();
privatestaticfinalintTHREAD_COUNT=300;
privateCountDownLatchlatch=newCountDownLatch(THREAD_COUNT);
privateCyclicBarrierbarrier=newCyclicBarrier(THREAD_COUNT);

publicvoidrun()throwsException{
StackTaskstackTask=newStackTask();
longbeginTime=System.currentTimeMillis();
for(inti=0;i<THREAD_COUNT;i++){
newThread(stackTask).start();
}
latch.await();
longendTime=System.currentTimeMillis();
System.out.println("StackconsumeTime:"+(endTime-beginTime)+"ms");

latch=newCountDownLatch(THREAD_COUNT);
barrier=newCyclicBarrier(THREAD_COUNT);
ConcurrentStackTaskconcurrentStackTask=newConcurrentStackTask();
beginTime=System.currentTimeMillis();
for(inti=0;i<THREAD_COUNT;i++){
newThread(concurrentStackTask).start();
}
latch.await();
endTime=System.currentTimeMillis();
System.out.println("ConcurrentStackconsumeTime:"+(endTime-beginTime)+"ms");
}

classStackTaskimplementsRunnable{

@Override
publicvoidrun(){
try{
barrier.await();
}catch(Exceptione){
e.printStackTrace();
}
for(inti=0;i<10;i++){
stack.push(Thread.currentThread().getName());
stack.pop();
}
latch.countDown();
}

}
classConcurrentStackTaskimplementsRunnable{

@Override
publicvoidrun(){
try{
barrier.await();
}catch(Exceptione){
e.printStackTrace();
}
for(inti=0;i<10;i++){
concurrentStack.push(Thread.currentThread().getName());
concurrentStack.pop();
}
latch.countDown();
}

}

}
/*
StackconsumeTime:94ms
ConcurrentStackconsumeTime:63ms
StackconsumeTime:78ms
ConcurrentStackconsumeTime:62ms
*/