Java性能优化方法

1.Java代码优化技巧

java代码优化

1、循环

通常把大循环放在里面,把小循环放在外面，例如：

[java]  view plain copy

1. for(int i=0; i<10;i++)  
2. {  
3.     for(int j=0; j<1000000;j++)  
4.     {   
5.             ...  
6.     }  
7. }  

把与循环index不相关的移到循环的外面 ，例如：

[java]  view plain copy

1. for(int i=0; terminal=x.length;i<terminal;i++)  
2. {x = x/scaleA * scaleB;}  
3. //应该该成：  
4. Double scale = scaleB*scaleA;  
5. for(int i=0; terminal=x.length;i<terminal;i++)  
6. {x = x/scale ;}  

在重要的循环里，消除循环终止判断时的方法调用 ，例如：

[java]  view plain copy

1. for(int i=0; i<collection.size();i++)  
2. { ... }  
3. //尽量减少对变量的重复计算  
4. for(int i=0; n=collection.size();i<n;i++)  
5. {...}  

尽量 不要在循环中使用 ：

[java]  view plain copy

1. Try {  
2. } catch() {  
3. }  

      应把其放置在最外层

循环内不要创建大量的临时变量

[java]  view plain copy

1. for(int i=1;i<=domainCount;i++){  
2.         ...   
3.        AuditResult auditResult = new AuditResult();  
4.         ...  
5. }  
6. //这种做法会在内存中保存N份这个对象的引用,会浪费大量的内存空间，改为  
7. AuditResult auditResult;  
8. for(int i=1;i<=domainCount;i++){  
9.         ...   
10.        auditResult=new AuditResult();  
11.         ...  
12. }  

2、字符串

     ■ 消除字符串连接

　　■创建长字符串时，总是使用StringBuffter代替String

　　■预先分配StringBuffer空间 StringBuffer sb = new StringBuffer(5000);

    ■ StringBuffer 和StringBuilder的区别：

    java.lang.StringBuffer线程安全的可变字符序列。一个类似于String 的字符串缓冲区，但不能修改。

    StringBuilder，与该类相比，通常应该优先使用java.lang.StringBuilder类，因为它支持所有相同的操作，但由于它不执行同步，所以速度更快。

3、异常

         ■ 异常只用于单个真正的错误条件，抛出一个异常和执行一个catch代码块花费是很高的(主要由于当创建一个异常时要获得线程栈的一个快照)，只当条件真的异常时才抛出一个异常

　　■ 抛出异常首先要创建一个新的对象。

　　Throwable接口的构造函数调用名为fillInStackTrace()的本地(Native)方法，fillInStackTrace()方法检查堆栈，收集调用跟踪信息。

　　只要有异常被抛出，JVM就必须调整调用堆栈，因为在处理过程中创建了一个新的对象。

　　异常只能用于错误处理，不应该用来控制程序流程。

　　■使编译器和运行时最优化，将几个方法调用放在一个try/catch块中，而不是为每个方法调用实现几个try/catch块，例如：

[java]  view plain copy

1. try{   
2.     Some.method1(); //Difficut for java1.4   
3. }catch(method1Exception e){   
4.     handle exception 1 // to optimize this code   
5. }  
6. try{   
7.     Some.method2(); //Difficut for java1.4   
8. }catch(method2Exception e){   
9.     handle exception 2 // to optimize this code   
10. }  
11. try{   
12.     Some.method3(); //Difficut for java1.4   
13. }catch(method3Exception e){   
14.     handle exception 3 // to optimize this code   
15. }  
16. //应该写为：  
17. try{   
18.     //Difficut for java1.4   
19.     Some.method1();   
20.     Some.method2();   
21.     Some.method3();   
22. }catch(method1Exception e){   
23.     handle exception 1   
24. }catch(method2Exception e){   
25.     handle exception 2   
26. }catch(method3Exception e){   
27.     handle exception 3   
28. }  

4、尽量指定类的final修饰符

          ■带有final修饰符的类是不可派生的。在Java核心API中，有许多应用final的例子，例如java.lang.String。其为String类指定final也防止了人们覆盖length()方法。

　　另外，如果指定一个类为final，则该类所有的方法都是final。Java编译器会寻找机会内联(inline)所有的final方法(这和具体的编译器实现有关)。此举能够使性能平均提高50%。

5、尽量使用局部变量

          ■调用方法时传递的参数以及在调用中创建的临时变量都保存在栈(Stack)中，速度较快。其他变量，如静态变量、实例变量等，都在堆(Heap)中创建，速度较慢。另外，依赖于具体的编译器/JVM，局部变量还可能得到进一步优化

6、乘法和除法

[java]  view plain copy

1. for (val = 0; val < 100000; val +=5) {   
2.     alterX = val * 8;   
3.     myResult = val * 2;  
4. }  
5. //优化后：  
6. for (val = 0; val < 100000; val += 5) {   
7.     alterX = val << 3;   
8.     myResult = val << 1;  
9. }  

这个还需要看具体情况，并不是所有的乘除法都能这样优化。

7、array(数组) 和 ArrayList的使用

    array（[]）：最高效；但是其容量固定且无法动态改变；

    ArrayList：容量可动态增长；但牺牲效率；

    基于效率和类型检验，应尽可能使用array，无法确定数组大小时才使用ArrayList。

    ArrayList内部封装了一个Object类型的数组，从一般的意义来说，它和数组没有本质的差别，甚至于ArrayList的许多方法，如Index、IndexOf、Contains、Sort等都是在内部数组的基础上直接调用Array的对应方法。

8、在JAVA + ORACLE的应用系统开发中，java中内嵌的SQL语句尽量使用大写的形式，以减轻ORACLE解析器的解析负担

9、由于JVM的有其自身的GC机制，不需要程序开发者的过多考虑，从一定程度上减轻了开发者负担，但同时也遗漏了隐患，过分的创建对象会消耗系统的大量内存，严重时会导致内存泄露，因此，保证过期对象的及时回收具有重要意义。JVM回收垃圾的条件是：对象不在被引用；然而，JVM的GC并非十分的机智，即使对象满足了垃圾回收的条件也不一定会被立即回收。所以，建议我们在对象使用完毕，应手动置成null，这样也可以提供性能。

10、尽量采用lazy loading 的策略

即在需要的时候才开始创建，例如：

[java]  view plain copy

1. String str = “aaa”;   
2. if(i == 1) {  
3.     list.add(str);   
4. }  
5. //应替换为：  
6. if(i == 1)   
7. {  
8.     String str = “aaa”;   
9.     list.add(str);   
10. }   

11、在使用同步机制时，应尽量使用方法同步代替代码块同步

12、当复制大量数据时，使用System.arraycopy()命令

JVM优化和性能优化建议

1.没有必要时请不用使用静态变量

    使用Java的开发者都知道，当某个对象被定义为stataic变量所引用，这个对象所占有的内存将不会被回收。有时，开发者会将经常调用的对象或者变量定义为static，以便提高程序的运行性能。因此，不是常用到的对象或者变量，不要定义为static类型的变量，尤其是静态类对象的定义，一定要仔细考虑是否有必要。例如

[java]  view plain copy print ?

1. public class X{   
2.     static Y a = new Y();   
3. }   

    类X创建了，没有被回收的话，静态变量a一直占用内存。

2.充分利用单例机制

    实用单例可以减少对资源的加载，缩短运行的时间，提高系统效率。但是，单例并不是所有地方都适用于。简单来说，单例可以适用于以下两个方面：

1.   控制资源的使用，通过线程同步来控制资源的并发访问；

2.   控制实例的产生，以达到节约资源的目的；

3. 减少对象的创建

尽量避免在经常调用的方法中循环使用new对象，由于系统不仅要花费时间来创建对象，而且还要花时间对这些对象进行垃圾回收和处理。设计模式中的享元模式就是为了减少对象的多次创建而来的。在我们可以控制的范围内，最大限度的重用对象；在有些时候，最好能用基本的数据类型或数组来替代对象。

4.使用final修饰符

带有final修饰符的类是不可派生的。在Java核心API中，有许多应用final的例子，例如java.lang.String。为String类指定final防止了使用者覆盖length()方法。另外，如果一个类是final的，则该类所有方法都是final的。Java编译器会寻找机会内联（inline）所有的final方法（这和具体的编译器实现有关）。此举能够使性能平均提高50%。

5.尽量使用局部变量

调用方法时传递的参数以及在调用中创建的临时变量都保存在分配给改方法的栈（Stack）中，速度较快。其他变量，如静态变量、实例变量等，都在堆（Heap）中创建，速度较慢。

6.处理好包装类型和基本类型两者的使用场所

    虽然包装类型和基本类型在使用过程中是可以相互转换，但它们两者所产生的内存区域是完全不同的，基本类型数据产生和处理都在栈中处理，而包装类型是对象，是在堆中产生实例。在集合类对象，有对象方面需要的处理适用包装类型，其他的情况，建议提倡使用基本类型。

7.学会用StringBuilder和StringBuffer
    这个两个类的区别就不用说了吧，单线程使用StringBuilder，多线程情况下使用StringBuffer，这样性能会有很大提升。

7.尽量不要使用finalize方法

实际上，将资源清理放在finalize方法中完成是非常不好的选择。由于GC的工作量很大，尤其是回收Young代内存时，大都会引起应用程序暂停，所以再选择使用finalize方法进行资源清理，会导致GC负担更大，程序运行效率更差。

8.尽量使用基本数据类型代替对象

 

String str = "hello";

上面这种方式会创建一个“hello”字符串，而且JVM的字符缓存池还会缓存这个字符串。

String str = new String("hello");

此时程序除创建字符串外，str所引用的String对象底层还包含一个char[]数组，这个char[]数组依次存放了h,e,l,l,o

   这个问题我也写个一个博客，请查看我写的有关性能优化的博客。

9.学会使用HashMap、ArrayList

HashTable、Vector等使用在多线程的场合，内部使用了同步机制，这个会降低程序的性能。
10. 深入理解HashMap原理

当你要创建一个比较大的hashMap时，充分利用另一个构造函数

public HashMap(int initialCapacity, float loadFactor)避免HashMap多次进行了hash重构,扩容是一件很耗费性能的事，在默认initialCapacity只有16，而loadFactor是 0.75，需要多大的容量，你最好能准确的估计你所需要的最佳大小，同样的Hashtable，Vectors也是一样的道理。

11.减少对变量的重复计算

如

for(int i=0;i<list.size();i++)

应该改写为：

for(int i=0,len=list.size();i<len;i++)

或者

for(int i = list.size(); I > -1; i--)

并且在循环中应该避免使用复杂的表达式，在循环中，循环条件会被反复计算，如果不使用复杂表达式，而使循环条件值不变的话，程序将会运行的更快。

12.避免不必要的对象创建

如

A a = new A();

if(i==1){list.add(a);}

应该改为

if(i==1){

A a = new A();

list.add(a);}

13.尽量在finally块中释放资源

程序中使用到的资源应当被释放，以避免资源泄漏。这最好在finally块中去做。不管程序执行的结果如何，finally块总是会执行的，以确保资源的正确关闭。

14.使用移位来代替乘法或者除法（'a/b'，仅适合2^n情况）的操作

"/"是一个代价很高的操作，使用移位的操作将会更快和更有效

如

int num = a / 4;

int num = a / 8;

应该改为

int num = a >> 2;

int num = a >> 3;

但注意的是使用移位应添加注释，因为移位操作不直观，比较难理解

同样的，对于'*'操作，使用移位的操作将会更快和更有效

如

int num = a * 4;

int num = a * 8;

应该改为

int num = a << 2;

int num = a << 3;

15. 确定StringBuffer的容量

StringBuffer 的构造器会创建一个默认大小（通常是16）的字符数组。在使用中，如果超出这个大小，就会重新分配内存，创建一个更大的数组，并将原先的数组复制过来，再丢弃旧的数组。在大多数情况下，你可以在创建 StringBuffer的时候指定大小，这样就避免了在容量不够的时候自动增长，以提高性能。

如：StringBufferbuffer = new StringBuffer(1000);  

16.尽量早释放无用对象的引用

大部分时，方法局部引用变量所引用的对象 会随着方法结束而变成垃圾，因此，大部分时候程序无需将局部，引用变量显式设为null。

例如：

Public void doJob(){ 

Object obj =new Object(); 

……  

Obj=null;  

}  

上面这个就没必要了，随着方法doJob()的执行完成，程序中obj引用变量的作用域会被gc回收。但是如果是改成下面：

public void doJob(){ 

Object obj =new Object(); 

……  

Obj=null;  

//执行耗时，耗内存操作；或调用耗时，耗内存的方法  

……  

}  

这时候就有必要将obj赋值为null，可以尽早的释放对Object对象的引用。

17.尽量避免使用split

除非是必须的，否则应该避免使用split，split由于支持正则表达式，所以效率比较低，如果是频繁的几十，几百万的调用将会耗费大量资源，如果确实需要频繁的调用split，可以考虑使用apache的StringUtils.split(string,char)，频繁split的可以缓存结果。

18.ArrayList & LinkedList

一个是线性表，一个是链表，一句话，随机查询尽量使用ArrayList，ArrayList优于LinkedList，LinkedList还要移动指针，添加删除的操作LinkedList优于ArrayList，ArrayList还要移动数据，不过这是理论性分析，事实未必如此，重要的是理解好数据结构。

19.尽量使用System.arraycopy ()代替通过来循环复制数组

System.arraycopy()要比通过循环来复制数组快的多

20.尽量缓存经常使用的对象

尽可能将经常使用的对象进行缓存，可以使用数组，或HashMap的容器来进行缓存，但这种方式可能导致系统占用过多的缓存，性能下降，推荐可以使用一些第三方的开源工具，如EhCache，Oscache进行缓存，他们基本都实现了FIFO/FLU等缓存算法。

21.尽量避免非常大的内存分配

有时候问题不是由当时的堆状态造成的，而是因为分配失败造成的。分配的内存块都必须是连续的，而随着堆heap越来越满，找到较大的连续块越来越困难。

22.慎用异常

当创建一个异常时，需要收集一个栈跟踪(stack track)，这个栈跟踪用于描述异常是在何处创建的。构建这些栈跟踪时需要为运行时栈做一份快照，正是这一部分开销很大。当需要创建一个 Exception 时，JVM 不得不说：先别动，我想就您现在的样子存一份快照，所以暂时停止入栈和出栈操作。栈跟踪不只包含运行时栈中的一两个元素，而是包含这个栈中的每一个元素。

如果您创建一个 Exception ，就得付出代价。好在捕获异常开销不大，因此可以使用 try-catch 将核心内容包起来。从技术上讲，您甚至可以随意地抛出异常，而不用花费很大的代价。招致性能损失的并不是 throw 操作——尽管在没有预先创建异常的情况下就抛出异常是有点不寻常。真正要花代价的是创建异常。幸运的是，好的编程习惯已教会我们，不应该不管三七二十一就抛出异常。异常是为异常的情况而设计的，使用时也应该牢记这一原则

Java性能优化技巧一

1.尽量使用final修饰符。
带有final修饰符的类是不可派生的。在JAVA核心API中，有许多应用final的例子，例如java.lang.String。为String类指定final防止了使用者覆盖length()方法。另外，如果一个类是final的，则该类所有方法都是final的。java编译器会寻找机会内联（inline）所有的final方法（这和具体的编译器实现有关）。此举能够使性能平均提高50%。

2.尽量重用对象。
特别是String对象的使用中，出现字符串连接情况时应使用StringBuffer代替，由于系统不仅要花时间生成对象，以后可能还需要花时间对这些对象进行垃圾回收和处理。因此生成过多的对象将会给程序的性能带来很大的影响。

3.尽量使用局部变量。
调用方法时传递的参数以及在调用中创建的临时变量都保存在栈（Stack）中，速度较快。其他变量，如静态变量，实例变量等，都在堆（Heap）中创建，速度较慢。

4.不要重复初始化变量。
默认情况下，调用类的构造函数时，java会把变量初始化成确定的值，所有的对象被设置成null，整数变量设置成0，float和double变量设置成0.0，逻辑值设置成false。当一个类从另一个类派生时，这一点尤其应该注意，因为用new关键字创建一个对象时，构造函数链中的所有构造函数都会被自动调用。
这里有个注意，给成员变量设置初始值但需要调用其他方法的时候，最好放在一个方法比如initXXX()中，因为直接调用某方法赋值可能会因为类尚未初始化而抛空指针异常，public int state = this.getState();

5.在java+Oracle的应用系统开发中，java中内嵌的SQL语言应尽量使用大写形式，以减少Oracle解析器的解析负担。

6.java编程过程中，进行数据库连接，I/O流操作，在使用完毕后，及时关闭以释放资源。因为对这些大对象的操作会造成系统大的开销。

7.过分的创建对象会消耗系统的大量内存，严重时，会导致内存泄漏，因此，保证过期的对象的及时回收具有重要意义。
JVM的GC并非十分智能，因此建议在对象使用完毕后，手动设置成null。

8.在使用同步机制时，应尽量使用方法同步代替代码块同步。

9.尽量减少对变量的重复计算。
比如for(int i=0;i<list.size();i++) 应修改为for(int i=0,len=list.size();i<len;i++)

10.采用在需要的时候才开始创建的策略。
例如：String str="abc";
if(i==1){ list.add(str);}
应修改为：
if(i==1){String str="abc"; list.add(str);}

11.慎用异常，异常对性能不利。
抛出异常首先要创建一个新的对象。Throwable接口的构造函数调用名为fillInStackTrace()的本地方法，fillInStackTrace()方法检查栈，收集调用跟踪信息。只要有异常被抛出，VM就必须调整调用栈，因为在处理过程中创建了一个新的对象。
异常只能用于错误处理，不应该用来控制程序流程。

12.不要在循环中使用Try/Catch语句，应把Try/Catch放在循环最外层。
Error是获取系统错误的类，或者说是虚拟机错误的类。不是所有的错误Exception都能获取到的，虚拟机报错Exception就获取不到，必须用Error获取。

13.通过StringBuffer的构造函数来设定他的初始化容量，可以明显提升性能。
StringBuffer的默认容量为16，当StringBuffer的容量达到最大容量时，她会将自身容量增加到当前的2倍+2，也就是2*n+2。无论何时，只要StringBuffer到达她的最大容量，她就不得不创建一个新的对象数组，然后复制旧的对象数组，这会浪费很多时间。所以给StringBuffer设置一个合理的初始化容量值，是很有必要的！

14.合理使用java.util.Vector。
Vector与StringBuffer类似，每次扩展容量时，所有现有元素都要赋值到新的存储空间中。Vector的默认存储能力为10个元素，扩容加倍。
vector.add(index,obj) 这个方法可以将元素obj插入到index位置，但index以及之后的元素依次都要向下移动一个位置（将其索引加 1）。 除非必要，否则对性能不利。
同样规则适用于remove(int index)方法，移除此向量中指定位置的元素。将所有后续元素左移（将其索引减 1）。返回此向量中移除的元素。所以删除vector最后一个元素要比删除第1个元素开销低很多。删除所有元素最好用removeAllElements()方法。
如果要删除vector里的一个元素可以使用 vector.remove(obj)；而不必自己检索元素位置，再删除，如int index = indexOf（obj）;vector.remove(index)；

15.当复制大量数据时，使用System.arraycopy();

16.代码重构，增加代码的可读性。

17.不用new关键字创建对象的实例。
用new关键词创建类的实例时，构造函数链中的所有构造函数都会被自动调用。但如果一个对象实现了Cloneable接口，我们可以调用她的clone()方法。clone()方法不会调用任何类构造函数。
下面是Factory模式的一个典型实现。
public static Credit getNewCredit()
{
    return new Credit();
}
改进后的代码使用clone()方法，
private static Credit BaseCredit = new Credit();
public static Credit getNewCredit()
{
    return (Credit)BaseCredit.clone();
}

18.乘除法如果可以使用位移，应尽量使用位移，但最好加上注释，因为位移操作不直观，难于理解。

19.不要将数组声明为：public static final。

20.HaspMap的遍历。
Map<String, String[]> paraMap = new HashMap<String, String[]>();
for( Entry<String, String[]> entry : paraMap.entrySet() )
{
    String appFieldDefId = entry.getKey();
    String[] values = entry.getValue();
}
利用散列值取出相应的Entry做比较得到结果，取得entry的值之后直接取key和value。

21.array(数组)和ArrayList的使用。
array 数组效率最高，但容量固定，无法动态改变，ArrayList容量可以动态增长，但牺牲了效率。

22.单线程应尽量使用 HashMap, ArrayList,除非必要，否则不推荐使用HashTable,Vector，她们使用了同步机制，而降低了性能。

23.StringBuffer,StringBuilder的区别在于：java.lang.StringBuffer 线程安全的可变字符序列。一个类似于String的字符串缓冲区，但不能修改。StringBuilder与该类相比，通常应该优先使用StringBuilder类，因为她支持所有相同的操作，但由于她不执行同步，所以速度更快。为了获得更好的性能，在构造StringBuffer或StringBuilder时应尽量指定她的容量。当然如果不超过16个字符时就不用了。
相同情况下，使用StringBuilder比使用StringBuffer仅能获得10%~15%的性能提升，但却要冒多线程不安全的风险。综合考虑还是建议使用StringBuffer。

24.尽量使用基本数据类型代替对象。

25.用简单的数值计算代替复杂的函数计算，比如查表方式解决三角函数问题。

26.使用具体类比使用接口效率高，但结构弹性降低了，但现代IDE都可以解决这个问题。

27.考虑使用静态方法，
如果你没有必要去访问对象的外部，那么就使你的方法成为静态方法。她会被更快地调用，因为她不需要一个虚拟函数导向表。这同事也是一个很好的实践，因为她告诉你如何区分方法的性质，调用这个方法不会改变对象的状态。

28.应尽可能避免使用内在的GET,SET方法。
android编程中，虚方法的调用会产生很多代价，比实例属性查询的代价还要多。我们应该在外包调用的时候才使用get，set方法，但在内部调用的时候，应该直接调用。

29.避免枚举，浮点数的使用。

30.二维数组比一维数组占用更多的内存空间，大概是10倍计算。

31.SQLite数据库读取整张表的全部数据很快，但有条件的查询就要耗时30-50MS,大家做这方面的时候要注意，尽量少用，尤其是嵌套查找！

Java Web性能优化总结

一、性能测试指标

1.响应时间

2.最大并发数

3.系统吞吐量(TPS、QPS等)

4.服务器性能指标：Load、CPU使用、Memery使用、磁盘、网络IO(in/out)等。

二、性能优化方法总结

1.Web前端优化

①浏览器访问优化

    1)减少HTTP请求：合并多个js文件、css文件、甚至合并图片

    2)使用浏览器缓存，缓存js、css、logo等相对静态的资源,使用HTTP头中的Cache-Control中的Expires属性设置浏览器缓存。

    3)使用压缩传输html、js、css等

    4)css放最上面、js放最下面(页面解析时用到的js除外)

    5)减少Cookie，css、js等有时不需要cookie，所以可以使用独立的域名。

②CDN加速

    1)网络运营商级别的缓存，一般缓存的是静态资源

③反向代理

1)网站内部的缓存，用于缓存相对静态的资源，可以设置使用内部通知机制设置过期策咯。

2.应用服务器性能优化

①分布式缓存

1)缓存一致性

2)缓存可用性

3)缓存预热

4)缓存过期策略

5)缓存穿透避免、缓存容灾

②异步操作

1)通知机制、消息队列

③.使用集群进行负载均衡

④.代码优化

1)多线程

2)资源复用

    a)数据库连接、网络连接、线程、复用

    b)方案：对象池、单例

    c)案例：线程池、数据库连接池、Spring中的Dao、Service等单例

3)JVM GC参数调优

    a)合理分配jvm'运行的堆内存

    b)合理设置新生代和老年代的大小

3.存储性能优化

    ①使用索引、B+树、LSM树

    ②索引缓存尽量全在内存

    ③使用固态硬盘SSD

Java性能优化技巧

、通用篇

　　“通用篇”讨论的问题适合于大多数Java应用。

　　1.1 不用new关键词创建类的实例

　　用new关键词创建类的实例时，构造函数链中的所有构造函数都会被自动调用。但如果一个对象实现了Cloneable接口，我们可以调用它的clone()方法。clone()方法不会调用任何类构造函数。

　　在使用设计模式（Design Pattern）的场合，如果用Factory模式创建对象，则改用clone()方法创建新的对象实例非常简单。例如，下面是Factory模式的一个典型实现：

public static Credit getNewCredit() {
return new Credit();
}

　　改进后的代码使用clone()方法，如下所示：

private static Credit BaseCredit = new Credit();
public static Credit getNewCredit() {
return (Credit) BaseCredit.clone();
}

　　上面的思路对于数组处理同样很有用。

　　1.2 使用非阻塞I/O

　　版本较低的JDK不支持非阻塞I/O API。为避免I/O阻塞，一些应用采用了创建大量线程的办法（在较好的情况下，会使用一个缓冲池）。这种技术可以在许多必须支持并发I/O流的应用中见到，如Web服务器、报价和拍卖应用等。然而，创建Java线程需要相当可观的开销。

　　JDK 1.4引入了非阻塞的I/O库（java.nio）。如果应用要求使用版本较早的JDK，在这里有一个支持非阻塞I/O的软件包。

　　请参见Sun中国网站的《调整Java的I/O性能》。

　　1.3 慎用异常

　　异常对性能不利。抛出异常首先要创建一个新的对象。Throwable接口的构造函数调用名为fillInStackTrace()的本地（Native）方法，fillInStackTrace()方法检查堆栈，收集调用跟踪信息。只要有异常被抛出，VM就必须调整调用堆栈，因为在处理过程中创建了一个新的对象。

　　异常只能用于错误处理，不应该用来控制程序流程。

　　1.4 不要重复初始化变量

　　默认情况下，调用类的构造函数时， Java会把变量初始化成确定的值：所有的对象被设置成null，整数变量（byte、short、int、long）设置成0，float和 double变量设置成0.0，逻辑值设置成false。当一个类从另一个类派生时，这一点尤其应该注意，因为用new关键词创建一个对象时，构造函数链中的所有构造函数都会被自动调用。

　　1.5 尽量指定类的final修饰符

　　带有final修饰符的类是不可派生的。在Java核心API中，有许多应用final的例子，例如java.lang.String。为String类指定final防止了人们覆盖length()方法。

　　另外，如果指定一个类为final，则该类所有的方法都是final。Java编译器会寻找机会内联（inline）所有的final方法（这和具体的编译器实现有关）。此举能够使性能平均提高50%。

　　1.6 尽量使用局部变量

　　调用方法时传递的参数以及在调用中创建的临时变量都保存在栈（Stack）中，速度较快。其他变量，如静态变量、实例变量等，都在堆（Heap）中创建，速度较慢。另外，依赖于具体的编译器/JVM，局部变量还可能得到进一步优化。请参见《尽可能使用堆栈变量》。

　　1.7 乘法和除法

　　考虑下面的代码：

for (val = 0; val < 100000; val +=5) { alterX = val * 8; myResult = val * 2; }

　　用移位操作替代乘法操作可以极大地提高性能。下面是修改后的代码：

for (val = 0; val < 100000; val += 5) { alterX = val << 3; myResult = val << 1; }

　　修改后的代码不再做乘以8的操作，而是改用等价的左移3位操作，每左移1位相当于乘以2。相应地，右移1位操作相当于除以2。值得一提的是，虽然移位操作速度快，但可能使代码比较难于理解，所以最好加上一些注释。

2 回顶部

二、J2EE篇

　　前面介绍的改善性能技巧适合于大多数Java应用，接下来要讨论的问题适合于使用JSP、EJB或JDBC的应用。

　　2.1 使用缓冲标记

　　一些应用服务器加入了面向JSP的缓冲标记功能。例如，BEA的WebLogic Server从6.0版本开始支持这个功能，Open Symphony工程也同样支持这个功能。JSP缓冲标记既能够缓冲页面片断，也能够缓冲整个页面。当JSP页面执行时，如果目标片断已经在缓冲之中，则生成该片断的代码就不用再执行。页面级缓冲捕获对指定URL的请求，并缓冲整个结果页面。对于购物篮、目录以及门户网站的主页来说，这个功能极其有用。对于这类应用，页面级缓冲能够保存页面执行的结果，供后继请求使用。

　　对于代码逻辑复杂的页面，利用缓冲标记提高性能的效果比较明显；反之，效果可能略逊一筹。

　　请参见《用缓冲技术提高JSP应用的性能和稳定性》。

　　2.2 始终通过会话Bean访问实体Bean

　　直接访问实体Bean不利于性能。当客户程序远程访问实体Bean时，每一个get方法都是一个远程调用。访问实体Bean的会话Bean是本地的，能够把所有数据组织成一个结构，然后返回它的值。

　　用会话Bean封装对实体Bean的访问能够改进事务管理，因为会话Bean只有在到达事务边界时才会提交。每一个对get方法的直接调用产生一个事务，容器将在每一个实体Bean的事务之后执行一个“装入-读取”操作。

　　一些时候，使用实体Bean会导致程序性能不佳。如果实体Bean的唯一用途就是提取和更新数据，改成在会话Bean之内利用JDBC访问数据库可以得到更好的性能。

　　2.3 选择合适的引用机制

　　在典型的JSP应用系统中，页头、页脚部分往往被抽取出来，然后根据需要引入页头、页脚。当前，在JSP页面中引入外部资源的方法主要有两种：include指令，以及include动作。

　　include指令：例如<%@ include file="copyright.html" %>。该指令在编译时引入指定的资源。在编译之前，带有include指令的页面和指定的资源被合并成一个文件。被引用的外部资源在编译时就确定，比运行时才确定资源更高效。 
include动作：例如<jsp:include page="copyright.jsp" />。该动作引入指定页面执行后生成的结果。由于它在运行时完成，因此对输出结果的控制更加灵活。但时，只有当被引用的内容频繁地改变时，或者在对主页面的请求没有出现之前，被引用的页面无法确定时，使用include动作才合算。

　　2.4 在部署描述器中设置只读属性

　　实体Bean的部署描述器允许把所有get方法设置成“只读”。当某个事务单元的工作只包含执行读取操作的方法时，设置只读属性有利于提高性能，因为容器不必再执行存储操作。

　　2.5 缓冲对EJB Home的访问

　　EJB Home接口通过JNDI名称查找获得。这个操作需要相当可观的开销。JNDI查找最好放入Servlet的init()方法里面。如果应用中多处频繁地出现EJB访问，最好创建一个EJBHomeCache类。EJBHomeCache类一般应该作为singleton实现。

　　2.6 为EJB实现本地接口

　　本地接口是EJB 2.0规范新增的内容，它使得Bean能够避免远程调用的开销。请考虑下面的代码。

PayBeanHome home = (PayBeanHome) 
javax.rmi.PortableRemoteObject.narrow 
(ctx.lookup ("PayBeanHome"), PayBeanHome.class); 
PayBean bean = (PayBean) 
javax.rmi.PortableRemoteObject.narrow 
(home.create(), PayBean.class);

　　第一个语句表示我们要寻找Bean的Home接口。这个查找通过JNDI进行，它是一个RMI调用。然后，我们定位远程对象，返回代理引用，这也是一个 RMI调用。第二个语句示范了如何创建一个实例，涉及了创建IIOP请求并在网络上传输请求的stub程序，它也是一个RMI调用。

　　要实现本地接口，我们必须作如下修改：

　　方法不能再抛出java.rmi.RemoteException异常，包括从RemoteException派生的异常，比如 TransactionRequiredException、TransactionRolledBackException和 NoSuchObjectException。EJB提供了等价的本地异常，如TransactionRequiredLocalException、 TransactionRolledBackLocalException和NoSuchObjectLocalException。

　　所有数据和返回值都通过引用的方式传递，而不是传递值。 
　　本地接口必须在EJB部署的机器上使用。简而言之，客户程序和提供服务的组件必须在同一个JVM上运行。 
　　如果Bean实现了本地接口，则其引用不可串行化。 
　　请参见《用本地引用提高EJB访问效率》。

3 回顶部

　　2.7 生成主键

　　在EJB之内生成主键有许多途径，下面分析了几种常见的办法以及它们的特点。

　　利用数据库内建的标识机制（SQL Server的IDENTITY或Oracle的SEQUENCE）。这种方法的缺点是EJB可移植性差。

　　由实体Bean自己计算主键值（比如做增量操作）。它的缺点是要求事务可串行化，而且速度也较慢。

　　利用NTP之类的时钟服务。这要求有面向特定平台的本地代码，从而把Bean固定到了特定的OS之上。另外，它还导致了这样一种可能，即在多CPU的服务器上，同一个毫秒之内生成了两个主键。

　　借鉴Microsoft的思路，在Bean中创建一个GUID。然而，如果不求助于JNI，Java不能确定网卡的MAC地址；如果使用JNI，则程序就要依赖于特定的OS。

　　还有其他几种办法，但这些办法同样都有各自的局限。似乎只有一个答案比较理想：结合运用RMI和JNDI。先通过RMI注册把RMI远程对象绑定到JNDI树。客户程序通过JNDI进行查找。下面是一个例子：

public class keyGenerator extends UnicastRemoteObject implements Remote { 
private static long KeyValue = System.currentTimeMillis(); 
public static synchronized long getKey() throws RemoteException { return KeyValue++; }

　　2.8 及时清除不再需要的会话

　　为了清除不再活动的会话，许多应用服务器都有默认的会话超时时间，一般为30分钟。当应用服务器需要保存更多会话时，如果内存容量不足，操作系统会把部分内存数据转移到磁盘，应用服务器也可能根据“最近最频繁使用”（Most Recently Used）算法把部分不活跃的会话转储到磁盘，甚至可能抛出“内存不足”异常。在大规模系统中，串行化会话的代价是很昂贵的。当会话不再需要时，应当及时调用HttpSession.invalidate()方法清除会话。HttpSession.invalidate()方法通常可以在应用的退出页面调用。

　　2.9 在JSP页面中关闭无用的会话

　　对于那些无需跟踪会话状态的页面，关闭自动创建的会话可以节省一些资源。使用如下page指令：

<%@ page session="false"%>

　　2.10 Servlet与内存使用

　　许多开发者随意地把大量信息保存到用户会话之中。一些时候，保存在会话中的对象没有及时地被垃圾回收机制回收。从性能上看，典型的症状是用户感到系统周期性地变慢，却又不能把原因归于任何一个具体的组件。如果监视JVM的堆空间，它的表现是内存占用不正常地大起大落。

　　解决这类内存问题主要有二种办法。第一种办法是，在所有作用范围为会话的Bean中实现HttpSessionBindingListener接口。这样，只要实现valueUnbound()方法，就可以显式地释放Bean使用的资源。

　　另外一种办法就是尽快地把会话作废。大多数应用服务器都有设置会话作废间隔时间的选项。另外，也可以用编程的方式调用会话的 setMaxInactiveInterval()方法，该方法用来设定在作废会话之前，Servlet容器允许的客户请求的最大间隔时间，以秒计。

　　2.11 HTTP Keep-Alive

　　Keep-Alive功能使客户端到服务器端的连接持续有效，当出现对服务器的后继请求时，Keep-Alive功能避免了建立或者重新建立连接。市场上的大部分Web服务器，包括iPlanet、IIS和Apache，都支持HTTP Keep-Alive。对于提供静态内容的网站来说，这个功能通常很有用。但是，对于负担较重的网站来说，这里存在另外一个问题：虽然为客户保留打开的连接有一定的好处，但它同样影响了性能，因为在处理暂停期间，本来可以释放的资源仍旧被占用。当Web服务器和应用服务器在同一台机器上运行时，Keep- Alive功能对资源利用的影响尤其突出。

　　2.12 JDBC与Unicode

　　想必你已经了解一些使用JDBC时提高性能的措施，比如利用连接池、正确地选择存储过程和直接执行的SQL、从结果集删除多余的列、预先编译SQL语句，等等。

　　除了这些显而易见的选择之外，另一个提高性能的好选择可能就是把所有的字符数据都保存为Unicode（代码页13488）。Java以Unicode形式处理所有数据，因此，数据库驱动程序不必再执行转换过程。但应该记住：如果采用这种方式，数据库会变得更大，因为每个Unicode字符需要2个字节存储空间。另外，如果有其他非Unicode的程序访问数据库，性能问题仍旧会出现，因为这时数据库驱动程序仍旧必须执行转换过程。

　　2.13 JDBC与I/O

　　如果应用程序需要访问一个规模很大的数据集，则应当考虑使用块提取方式。默认情况下，JDBC每次提取32行数据。举例来说，假设我们要遍历一个5000 行的记录集，JDBC必须调用数据库157次才能提取到全部数据。如果把块大小改成512，则调用数据库的次数将减少到10次。

　　在一些情形下这种技术无效。例如，如果使用可滚动的记录集，或者在查询中指定了FOR UPDATE，则块操作方式不再有效。

　　2.14 内存数据库

　　许多应用需要以用户为单位在会话对象中保存相当数量的数据，典型的应用如购物篮和目录等。由于这类数据可以按照行/列的形式组织，因此，许多应用创建了庞大的Vector或HashMap。在会话中保存这类数据极大地限制了应用的可伸缩性，因为服务器拥有的内存至少必须达到每个会话占用的内存数量乘以并发用户最大数量，它不仅使服务器价格昂贵，而且垃圾收集的时间间隔也可能延长到难以忍受的程度。

　　一些人把购物篮/目录功能转移到数据库层，在一定程度上提高了可伸缩性。然而，把这部分功能放到数据库层也存在问题，且问题的根源与大多数关系数据库系统的体系结构有关。对于关系数据库来说，运行时的重要原则之一是确保所有的写入操作稳定、可靠，因而，所有的性能问题都与物理上把数据写入磁盘的能力有关。关系数据库力图减少I/O操作，特别是对于读操作，但实现该目标的主要途径只是执行一套实现缓冲机制的复杂算法，而这正是数据库层第一号性能瓶颈通常总是 CPU的主要原因。

　　一种替代传统关系数据库的方案是，使用在内存中运行的数据库（In-memory Database），例如TimesTen。内存数据库的出发点是允许数据临时地写入，但这些数据不必永久地保存到磁盘上，所有的操作都在内存中进行。这样，内存数据库不需要复杂的算法来减少I/O操作，而且可以采用比较简单的加锁机制，因而速度很快。

4 回顶部

三、GUI篇

　　这一部分介绍的内容适合于图形用户界面的应用（Applet和普通应用），要用到AWT或Swing。

　　3.1 用JAR压缩类文件

　　Java档案文件（JAR文件）是根据JavaBean标准压缩的文件，是发布JavaBean组件的主要方式和推荐方式。JAR档案有助于减少文件体积，缩短下载时间。例如，它有助于Applet提高启动速度。一个JAR文件可以包含一个或者多个相关的Bean以及支持文件，比如图形、声音、HTML 和其他资源。

　　要在HTML/JSP文件中指定JAR文件，只需在Applet标记中加入ARCHIVE = "name.jar"声明。

　　请参见《使用档案文件提高 applet 的加载速度》。

　　3.2 提示Applet装入进程

　　你是否看到过使用Applet的网站，注意到在应该运行Applet的地方出现了一个占位符？当Applet的下载时间较长时，会发生什么事情？最大的可能就是用户掉头离去。在这种情况下，显示一个Applet正在下载的信息无疑有助于鼓励用户继续等待。

　　下面我们来看看一种具体的实现方法。首先创建一个很小的Applet，该Applet负责在后台下载正式的Applet：

import java.applet.Applet;
import java.applet.AppletStub;
import java.awt.Label;
import java.awt.Graphics;
import java.awt.GridLayout; 
public class PreLoader extends Applet implements Runnable, AppletStub {
String largeAppletName;
Label label;
public void init() {
// 要求装载的正式Applet
largeAppletName = getParameter("applet");
// “请稍等”提示信息
label = new Label("请稍等..." + largeAppletName);
add(label);
} 
public void run(){
try {
// 获得待装载Applet的类
Class largeAppletClass = Class.forName(largeAppletName); 
// 创建待装载Applet的实例
Applet largeApplet = (Applet)largeAppletClass.newInstance(); 
// 设置该Applet的Stub程序
largeApplet.setStub(this); 
// 取消“请稍等”信息
remove(label); 
// 设置布局
setLayout(new GridLayout(1, 0));
add(largeApplet); 
// 显示正式的Applet
largeApplet.init();
largeApplet.start();
}
catch (Exception ex) {
// 显示错误信息
label.setText("不能装入指定的Applet");
} 
// 刷新屏幕
validate();
} 
public void appletResize(int width, int height) {
// 把appletResize调用从stub程序传递到Applet
resize(width, height);
}
}

　　编译后的代码小于2K，下载速度很快。代码中有几个地方值得注意。首先，PreLoader实现了AppletStub接口。一般地，Applet从调用者判断自己的codebase。在本例中，我们必须调用setStub()告诉Applet到哪里提取这个信息。另一个值得注意的地方是， AppletStub接口包含许多和Applet类一样的方法，但appletResize()方法除外。这里我们把对appletResize()方法的调用传递给了resize()方法。

5 回顶部

　　3.3 在画出图形之前预先装入它

　　ImageObserver接口可用来接收图形装入的提示信息。ImageObserver接口只有一个方法imageUpdate()，能够用一次repaint()操作在屏幕上画出图形。下面提供了一个例子。

public boolean imageUpdate(Image img, int flags, int x, int y, int w, int h) {
if ((flags & ALLBITS) !=0 {
repaint();
}
else if (flags & (ERROR |ABORT )) != 0) {
error = true;
// 文件没有找到，考虑显示一个占位符
repaint();
}
return (flags & (ALLBITS | ERROR| ABORT)) == 0;
}

　　当图形信息可用时，imageUpdate()方法被调用。如果需要进一步更新，该方法返回true；如果所需信息已经得到，该方法返回false。

　　3.4 覆盖update方法

　　update()方法的默认动作是清除屏幕，然后调用paint()方法。如果使用默认的update()方法，频繁使用图形的应用可能出现显示闪烁现象。要避免在paint()调用之前的屏幕清除操作，只需按照如下方式覆盖update()方法：

public void update(Graphics g) {
paint(g);
}

　　更理想的方案是：覆盖update()，只重画屏幕上发生变化的区域，如下所示：

public void update(Graphics g) {
g.clipRect(x, y, w, h);
paint(g);
}

　　3.5 延迟重画操作

　　对于图形用户界面的应用来说，性能低下的主要原因往往可以归结为重画屏幕的效率低下。当用户改变窗口大小或者滚动一个窗口时，这一点通常可以很明显地观察到。改变窗口大小或者滚动屏幕之类的操作导致重画屏幕事件大量地、快速地生成，甚至超过了相关代码的执行速度。对付这个问题最好的办法是忽略所有“迟到” 的事件。

　　建议在这里引入一个数毫秒的时差，即如果我们立即接收到了另一个重画事件，可以停止处理当前事件转而处理最后一个收到的重画事件；否则，我们继续进行当前的重画过程。

　　如果事件要启动一项耗时的工作，分离出一个工作线程是一种较好的处理方式；否则，一些部件可能被“冻结”，因为每次只能处理一个事件。下面提供了一个事件处理的简单例子，但经过扩展后它可以用来控制工作线程。

public static void runOnce(String id, final long milliseconds) {
synchronized(e_queue) { // e_queue: 所有事件的集合
if (!e_queue.containsKey(id)) {
e_queue.put(token, new LastOne());
}
} 
final LastOne lastOne = (LastOne) e_queue.get(token);
final long time = System.currentTimeMillis(); // 获得当前时间
lastOne.time = time; 
(new Thread() {public void run() {
if (milliseconds > 0) {
try {Thread.sleep(milliseconds);} // 暂停线程
catch (Exception ex) {}
}
synchronized(lastOne.running) { // 等待上一事件结束
if (lastOne.time != time) // 只处理最后一个事件
return;
}
}}).start();
} 
private static Hashtable e_queue = new Hashtable(); 
private static class LastOne {
public long time=0;
public Object running = new Object();
}

6 回顶部

　　3.6 使用双缓冲区

　　在屏幕之外的缓冲区绘图，完成后立即把整个图形显示出来。由于有两个缓冲区，所以程序可以来回切换。这样，我们可以用一个低优先级的线程负责画图，使得程序能够利用空闲的CPU时间执行其他任务。下面的伪代码片断示范了这种技术。

Graphics myGraphics;
Image myOffscreenImage = createImage(size().width, size().height);
Graphics offscreenGraphics = myOffscreenImage.getGraphics(); 
offscreenGraphics.drawImage(img, 50, 50, this);
myGraphics.drawImage(myOffscreenImage, 0, 0, this);

　　3.7 使用BufferedImage

　　Java JDK 1.2使用了一个软显示设备，使得文本在不同的平台上看起来相似。为实现这个功能，Java必须直接处理构成文字的像素。由于这种技术要在内存中大量地进行位复制操作，早期的JDK在使用这种技术时性能不佳。为解决这个问题而提出的Java标准实现了一种新的图形类型，即BufferedImage。

　　BufferedImage子类描述的图形带有一个可访问的图形数据缓冲区。一个BufferedImage包含一个ColorModel和一组光栅图形数据。这个类一般使用RGB（红、绿、蓝）颜色模型，但也可以处理灰度级图形。它的构造函数很简单，如下所示： 
public BufferedImage (int width, int height, int imageType)

　　ImageType允许我们指定要缓冲的是什么类型的图形，比如5-位RGB、8-位RGB、灰度级等。

　　3.8 使用VolatileImage

　　许多硬件平台和它们的操作系统都提供基本的硬件加速支持。例如，硬件加速一般提供矩形填充功能，和利用CPU完成同一任务相比，硬件加速的效率更高。由于硬件加速分离了一部分工作，允许多个工作流并发进行，从而缓解了对CPU和系统总线的压力，使得应用能够运行得更快。利用VolatileImage可以创建硬件加速的图形以及管理图形的内容。由于它直接利用低层平台的能力，性能的改善程度主要取决于系统使用的图形适配器。VolatileImage的内容随时可能丢失，也即它是“不稳定的（volatile）”。因此，在使用图形之前，最好检查一下它的内容是否丢失。VolatileImage有两个能够检查内容是否丢失的方法：

public abstract int validate(GraphicsConfiguration gc);
public abstract Boolean contentsLost();

　　每次从VolatileImage对象复制内容或者写入VolatileImage时，应该调用validate()方法。contentsLost()方法告诉我们，自从最后一次validate()调用之后，图形的内容是否丢失。

　　虽然VolatileImage是一个抽象类，但不要从它这里派生子类。VolatileImage应该通过 Component.createVolatileImage()或者 GraphicsConfiguration.createCompatibleVolatileImage()方法创建。

　　3.9 使用Window Blitting

　　进行滚动操作时，所有可见的内容一般都要重画，从而导致大量不必要的重画工作。许多操作系统的图形子系统，包括WIN32 GDI、MacOS和X/Windows，都支持Window Blitting技术。Window Blitting技术直接在屏幕缓冲区中把图形移到新的位置，只重画新出现的区域。要在Swing应用中使用Window Blitting技术，设置方法如下：

setScrollMode(int mode);

　　在大多数应用中，使用这种技术能够提高滚动速度。只有在一种情形下，Window Blitting会导致性能降低，即应用在后台进行滚动操作。如果是用户在滚动一个应用，那么它总是在前台，无需担心任何负面影响。