优化Java性能的诀窍
Java在九十年代中期出现以后，在赢得赞叹的同时，也引来了一些批评。赢得的赞叹主要是Java的跨平台的操作性，即所谓的”Write Once,Run Anywhere”.但由于Java的性能和运行效率同C相比，仍然有很大的差距，从而引来了很多的批评。
对于服务器端的应用程序，由于不大涉及到界面设计和程序的频繁重启，Java的性能问题看似不大明显，从而一些Java的技术，如JSP,Servlet,EJB等在服务器端编程方面得到了很大的应用，但实际上，Java的性能问题在服务器端依然存在。下面我将分四个方面来讨论Java的性能和执行效率以及提高Java性能的一些方法。 一．关于性能的基本知识 1．性能的定义 在我们讨论怎样提高Java的性能之前，我们需要明白“性能“的真正含义。我们一般定义如下五个方面作为评判性能的标准。 1） 运算的性能----哪一个算法的执行性能最好 2） 内存的分配----程序需要分配多少内存，运行时的效率和性能最高。 3） 启动的时间----程序启动需要多少时间。 4） 程序的可伸缩性-----程序在用户负载过重的情况下的表现。 5） 性能的认识------用户怎样才能认识到程序的性能。 对于不同的应用程序，对性能的要求也不同。例如，大部分的应用程序在启动时需要较长的时间，从而对启动时间的要求有所降低；服务器端的应用程序通常都分配有较大的内存空间，所以对内存的要求也有所降低。但是，这并不是所这两方面的性能可以被忽略。其次，算法的性能对于那些把商务逻辑运用到事务性操作的应用程序来讲非常重要。总的来讲，对应用程序的要求将决定对各个性能的优先级。 2．怎样才能提高JAVA的性能 提高JAVA的性能，一般考虑如下的四个主要方面： （1） 程序设计的方法和模式 一个良好的设计能提高程序的性能，这一点不仅适用于JAVA，也适用也任何的编程语言。因为它充分利用了各种资源，如内存，CPU,高速缓存，对象缓冲池及多线程，从而设计出高性能和可伸缩性强的系统。 当然，为了提高程序的性能而改变原来的设计是比较困难的，但是，程序性能的重要性常常要高于设计上带来的变化。因此，在编程开始之前就应该有一个好的设计模型和方法。 （2） JAVA布署的环境。 JAVA布署的环境就是指用来解释和执行JAVA字节码的技术，一般有如下五种。即解释指令技术(Interpreter Technology)，及时编译的技术(Just In Time Compilier Technology), 适应性优化技术（Adaptive Optimization Technology）, 动态优化，提前编译为机器码的技术（Dynamic Optimization,Ahead Of Time Technology）和编译为机器码的技术（Translator Technology）. 这些技术一般都通过优化线程模型，调整堆和栈的大小来优化JAVA的性能。在考虑提高JAVA的性能时，首先要找到影响JAVA性能的瓶颈（BottleNecks），在确认了设计的合理性后，应该调整JAVA布署的环境，通过改变一些参数来提高JAVA应用程序的性能。具体内容见第二节。 （3） JAVA应用程序的实现 当讨论应用程序的性能问题时，大多数的程序员都会考虑程序的代码，这当然是对的，当更重要的是要找到影响程序性能的瓶颈代码。为了找到这些瓶颈代码，我们一般会使用一些辅助的工具，如Jprobe,Optimizit,Vtune以及一些分析的工具如TowerJ Performance等。这些辅助的工具能跟踪应用程序中执行每个函数或方法所消耗掉的时间，从而改善程序的性能。 (4) 硬件和操作系统 为了提高JAVA应用程序的性能，而采用跟快的CPU和更多的内存，并认为这是提高程序性能的唯一方法，但事实并非如此。实践经验和事实证明，只有遭到了应用程序性能的瓶颈，从而采取适当得方法，如设计模式，布署的环境，操作系统的调整，才是最有效的。 3．程序中通常的性能瓶颈。 所有的应用程序都存在性能瓶颈，为了提高应用程序的性能，就要尽可能的减少程序的瓶颈。以下是在JAVA程序中经常存在的性能瓶颈。[img]http://www.computerworld.com.cn/htm/app/aprog/01_7_9_3a.gif[/img]
了解了这些瓶颈后，就可以有针对性的减少这些瓶颈，从而提高JAVA应用程序的性能 4. 提高JAVA程序性能的步骤 为了提高JAVA程序的性能，需要遵循如下的六个步骤。 a) 明确对性能的具体要求 在实施一个项目之前，必须要明确该项目对于程序性能的具体要求，如：这个应用程序要支持5000个并发的用户，并且响应时间要在5秒钟之内。但同时也要明白对于性能的要求不应该同对程序的其他要求冲突。 b) 了解当前程序的性能 你应该了解你的应用程序的性能同项目所要求性能之间的差距。通常的指标是单位时间内的处理数和响应时间，有时还会比较CPU和内存的利用率。 c) 找到程序的性能瓶颈 为了发现程序中的性能瓶颈，通常会使用一些分析工具，如：TowerJ Application Performance Analyzer或VTune来察看和分析程序堆栈中各个元素的消耗时间，从而正确的找到并改正引起性能降低的瓶颈代码，从而提高程序的性能。这些工具还能发现诸如过多的异常处理，垃圾回收等潜在的问题。 d) 采取适当的措施来提高性能 找到了引起程序性能降低的瓶颈代码后，我们就可以用前面介绍过的提高性能的四个方面，即设计模式，JAVA代码的实现，布署JAVA的环境和操作系统来提高应用程序的性能。具体内容将在下面的内容中作详细说明。 e) 只进行某一方面的修改来提高性能 一次只改变可能引起性能降低的某一方面，然后观察程序的性能是否有所提高，而不应该一次改变多个方面，因为这样你将不知道到底哪个方面的改变提高了程序的性能，哪个方面没有，即不能知道程序瓶颈在哪。 f) 返回到步骤c,继续作类似的工作，一直达到要求的性能为止。 二． JAVA布署的环境和编译技术 开发JAVA应用程序时，首先把JAVA的源程序编译为与平台无关的字节码。这些字节码就可以被各种基于JVM的技术所执行。这些技术主要分为两个大类。即基于解释的技术和基于提前编译为本地码的技术。其示意图如下：[img]http://www.computerworld.com.cn/htm/app/aprog/01_7_9_3b.gif[/img]
具体可分为如下的五类： a) 解释指令技术 其结构图和执行过程如下：[img]http://www.computerworld.com.cn/htm/app/aprog/01_7_9_3c.gif[/img]
JAVA的编译器首先把JAVA源文件编译为字节码。这些字节码对于JAVA虚拟机(JVM)来讲就是机器的指令码。然后，JAVA的解释器不断的循环取出字节码进行解释并执行。 这样做的优点是可以实现JAVA语言的跨平台，同时生成的字节码也比较紧凑。JAVA的一些优点，如安全性，动态性都得保持；但缺点是省生成的字节码没有经过什么优化，同全部编译好的本地码相比，速度比较慢。 b) 及时编译技术（Just In Time） 及时编译技术是为了解决指令解释技术效率比较低，速度比较慢的情况下提出的，其结构图如下所示。[img]http://www.computerworld.com.cn/htm/app/aprog/01_7_9_3d.gif[/img]
其主要变化是在JAVA程序执行之前，又JIT编译器把JAVA的字节码编译为机器码。从而在程序运行时直接执行机器码，而不用对字节码进行解释。同时对代码也进行了部分的优化。 这样做的优点是大大提高了JAVA程序的性能。同时，由于编译的结果并不在程序运行间保存，因此也节约了存储空间了加载程序的时间；缺点是由于JIT编译器对所有的代码都想优化，因此也浪费了很多的时间。 IBM和SUN公司都提供了相关的JIT产品。 c) 适应性优化技术（Adaptive Optimization Technology） 同JIT技术相比，适应性优化技术并不对所有的字节码进行优化。它会跟踪程序运行的成个过程，从而发现需要优化的代码，对代码进行动态的优化。对优化的代码，采取80/20的策略。从理论上讲，程序运行的时间越长，代码就越优化。其结构图如下： [img]http://www.computerworld.com.cn/htm/app/aprog/01_7_9_3e.gif[/img] 其优点是适应性优化技术充分利用了程序执行时的信息，发行程序的性能瓶颈，从而提高程序的性能；其缺点是在进行优化时可能会选择不当，发而降低了程序的性能。 其主要产品又IBM,SUN的HotSpot. d) 动态优化，提前编译为机器码的技术（Dynamic Optimization,Ahead Of Time） 动态优化技术充分利用了JAVA源码编译，字节码编译，动态编译和静态编译的技术。其输入时JAVA的原码或字节码，而输出是经过高度优化的可执行代码和个来动态库的混合(Window中是DLL文件，UNIX中是共享库.a .so文件)。其结构如下：[img]http://www.computerworld.com.cn/htm/app/aprog/01_7_9_3f.gif[/img]
其优点是能大大提高程序的性能；缺点是破坏了JAVA的可移植性，也对JAVA的安全带来了一定的隐患。 其主要产品是TowerJ3.0.三．优化JAVA程序设计和编码，提高JAVA程序性能的一些方法。
通过使用一些前面介绍过的辅助性工具来找到程序中的瓶颈，然后就可以对瓶颈部分的代码进行优化。一般有两种方案：即优化代码或更改设计方法。我们一般会选择后者，因为不去调用以下代码要比调用一些优化的代码更能提高程序的性能。而一个设计良好的程序能够精简代码，从而提高性能。 下面将提供一些在JAVA程序的设计和编码中，为了能够提高JAVA程序的性能，而经常采用的一些方法和技巧。 1．对象的生成和大小的调整。 JAVA程序设计中一个普遍的问题就是没有好好的利用JAVA语言本身提供的函数，从而常常会生成大量的对象（或实例）。由于系统不仅要花时间生成对象，以后可能还需花时间对这些对象进行垃圾回收和处理。因此，生成过多的对象将会给程序的性能带来很大的影响。 例1：关于String ,StringBuffer，+和append JAVA语言提供了对于String类型变量的操作。但如果使用不当，会给程序的性能带来影响。如下面的语句： String name=new String(“HuangWeiFeng”); System.out.println(name+”is my name”); 看似已经很精简了，其实并非如此。为了生成二进制的代码，要进行如下的步骤和操作。 （1） 生成新的字符串 new String(STR_1); （2） 复制该字符串。 （3） 加载字符串常量”HuangWeiFeng”(STR_2); （4） 调用字符串的构架器（Constructor）; （5） 保存该字符串到数组中（从位置0开始） （6） 从java.io.PrintStream类中得到静态的out变量 （7） 生成新的字符串缓冲变量new StringBuffer(STR_BUF_1); （8） 复制该字符串缓冲变量 （9） 调用字符串缓冲的构架器（Constructor）; （10） 保存该字符串缓冲到数组中（从位置1开始） （11） 以STR_1为参数，调用字符串缓冲(StringBuffer)类中的append方法。 （12） 加载字符串常量”is my name”(STR_3); （13） 以STR_3为参数，调用字符串缓冲(StringBuffer)类中的append方法。 （14） 对于STR_BUF_1执行toString命令。 （15） 调用out变量中的println方法，输出结果。 由此可以看出，这两行简单的代码，就生成了STR_1,STR_2,STR_3,STR_4和STR_BUF_1五个对象变量。这些生成的类的实例一般都存放在堆中。堆要对所有类的超类，类的实例进行初始化，同时还要调用类极其每个超类的构架器。而这些操作都是非常消耗系统资源的。因此，对对象的生成进行限制，是完全有必要的。 经修改，上面的代码可以用如下的代码来替换。 StringBuffer name=new StringBuffer(“HuangWeiFeng”); System.out.println(name.append(“is my name.”).toString()); 系统将进行如下的操作。 (1) 生成新的字符串缓冲变量new StringBuffer(STR_BUF_1); (2) 复制该字符串缓冲变量 (3) 加载字符串常量”HuangWeiFeng”(STR_1); (4) 调用字符串缓冲的构架器（Constructor）; (5) 保存该字符串缓冲到数组中（从位置1开始） (6) 从java.io.PrintStream类中得到静态的out变量 (7) 加载STR_BUF_1; (8) 加载字符串常量”is my name”(STR_2); (9) 以STR_2为参数，调用字符串缓冲(StringBuffer)实例中的append方法。 (10) 对于STR_BUF_1执行toString命令。(STR_3) (11)调用out变量中的println方法，输出结果。 由此可以看出，经过改进后的代码只生成了四个对象变量：STR_1,STR_2,STR_3和STR_BUF_1.你可能觉得少生成一个对象不会对程序的性能有很大的提高。但下面的代码段2的执行速度将是代码段1的2倍。因为代码段1生成了八个对象，而代码段2只生成了四个对象。 代码段1： String name= new StringBuffer(“HuangWeiFeng”); name+=”is my”; name+=”name”; 代码段2： StringBuffer name=new StringBuffer(“HuangWeiFeng”); name.append(“is my”); name.append(“name.”).toString(); 因此，充分的利用JAVA提供的库函数来优化程序，对提高JAVA程序的性能时非常重要的.其注意点主要有如下几方面； （1） 尽可能的使用静态变量（Static Class Variables） 如果类中的变量不会随他的实例而变化，就可以定义为静态变量，从而使他所有的实例都共享这个变量。 例： public class foo { SomeObject so=new SomeObject(); } 就可以定义为： public class foo { static SomeObject so=new SomeObject(); } （2） 不要对已生成的对象作过多的改变。 对于一些类(如：String类)来讲，宁愿在重新生成一个新的对象实例，而不应该修改已经生成的对象实例。 例： String name=”Huang”; name=”Wei”; name=”Feng”; 上述代码生成了三个String类型的对象实例。而前两个马上就需要系统进行垃圾回收处理。如果要对字符串进行连接的操作，性能将得更差。因为系统将不得为此生成更多得临时变量。如上例1所示。 （3） 生成对象时，要分配给它合理的空间和大小 JAVA中的很多类都有它的默认的空间分配大校对于StringBuffer类来讲，默认的分配空间大小是16个字符。如果在程序中使用StringBuffer的空间大小不是16个字符，那么就必须进行正确的初始化。 （4） 避免生成不太使用或生命周期短的对象或变量。 对于这种情况，因该定义一个对象缓冲池。以为管理一个对象缓冲池的开销要比频繁的生成和回收对象的开销小的多。 （5） 只在对象作用范围内进行初始化。 JAVA允许在代码的任何地方定义和初始化对象。这样，就可以只在对象作用的范围内进行初始化。从而节约系统的开销。 例： SomeObject so=new SomeObject(); If(x==1) then { Foo=so.getXX(); } 可以修改为： if(x==1) then { SomeObject so=new SomeObject(); Foo=so.getXX(); }2．异常(Exceptions)
JAVA语言中提供了try/catch来发方便用户捕捉异常，进行异常的处理。但是如果使用不当，也会给JAVA程序的性能带来影响。因此，要注意以下两点。 (1) 避免对应用程序的逻辑使用try/catch 如果可以用if,while等逻辑语句来处理，那么就尽可能的不用try/catch语句 (2) 重用异常 在必须要进行异常的处理时，要尽可能的重用已经存在的异常对象。以为在异常的处理中，生成一个异常对象要消耗掉大部分的时间。 3. 线程(Threading) 一个高性能的应用程序中一般都会用到线程。因为线程能充分利用系统的资源。在其他线程因为等待硬盘或网络读写而 时，程序能继续处理和运行。但是对线程运用不当，也会影响程序的性能。 例2：正确使用Vector类 Vector主要用来保存各种类型的对象（包括相同类型和不同类型的对象）。但是在一些情况下使用会给程序带来性能上的影响。这主要是由Vector类的两个特点所决定的。第一，Vector提供了线程的安全保护功能。即使Vector类中的许多方法同步。但是如果你已经确认你的应用程序是单线程，这些方法的同步就完全不必要了。第二，在Vector查找存储的各种对象时，常常要花很多的时间进行类型的匹配。而当这些对象都是同一类型时，这些匹配就完全不必要了。因此，有必要设计一个单线程的，保存特定类型对象的类或集合来替代Vector类.用来替换的程序如下（StringVector.java）： public class StringVector { private String [] data; private int count; public StringVector() { this(10); // default size is 10 } public StringVector(int initialSize) { data = new String[initialSize]; } public void add(String str) { // ignore null strings if(str == null) { return; } ensureCapacity(count + 1); data[count++] = str; } private void ensureCapacity(int minCapacity) { int oldCapacity = data.length; if (minCapacity > oldCapacity) { String oldData[] = data; int newCapacity = oldCapacity * 2; data = new String[newCapacity]; System.arraycopy(oldData, 0, data, 0, count); } } public void remove(String str) { if(str == null) { return // ignore null str } for(int i = 0; i < count; i++) { // check for a match if(data[i].equals(str)) { System.arraycopy(data,i+1,data,i,count-1); // copy data // allow previously valid array element be gc'd data[--count] = null; return; } } } public final String getStringAt(int index) { if(index < 0) { return null; } else if(index > count) { return null; // index is > # strings } else { return data[index]; // index is good } } /* * * * * * * * * * * * * * * *StringVector.java * * * * * * * * * * * * * * * * */ 因此，代码： Vector Strings=new Vector(); Strings.add(“One”); Strings.add(“Two”); String Second=(String)Strings.elementAt(1); 可以用如下的代码替换： StringVector Strings=new StringVector(); Strings.add(“One”); Strings.add(“Two”); String Second=Strings.getStringAt(1); 这样就可以通过优化线程来提高JAVA程序的性能。用于测试的程序如下（TestCollection.java）: import java.util.Vector; public class TestCollection { public static void main(String args []) { TestCollection collect = new TestCollection(); if(args.length == 0) { System.out.println( "Usage: java TestCollection [ vector | stringvector ]"); System.exit(1); } if(args[0].equals("vector")) { Vector store = new Vector(); long start = System.currentTimeMillis(); for(int i = 0; i < 1000000; i++) { store.addElement("string"); } long finish = System.currentTimeMillis(); System.out.println((finish-start)); start = System.currentTimeMillis(); for(int i = 0; i < 1000000; i++) { String result = (String)store.elementAt(i); } finish = System.currentTimeMillis(); System.out.println((finish-start)); } else if(args[0].equals("stringvector")) { StringVector store = new StringVector(); long start = System.currentTimeMillis(); for(int i = 0; i < 1000000; i++) { store.add("string"); } long finish = System.currentTimeMillis(); System.out.println((finish-start)); start = System.currentTimeMillis(); for(int i = 0; i < 1000000; i++) { String result = store.getStringAt(i); } finish = System.currentTimeMillis(); System.out.println((finish-start)); } } } /* * * * * * * * * * * * * * * *TestCollection.java * * * * * * * * * * * * * * * * */ 测试的结果如下（假设标准的时间为１，越小性能越好）：[img]http://www.computerworld.com.cn/htm/app/aprog/01_7_9_4.gif[/img]
关于线程的操作，要注意如下几个方面。 (1) 防止过多的同步 如上所示，不必要的同步常常会造成程序性能的下降。因此，如果程序是单线程，则一定不要使用同步。 (2) 同步方法而不要同步整个代码段 对某个方法或函数进行同步比对整个代码段进行同步的性能要好。 (3) 对每个对象使用多”锁”的机制来增大并发。 一般每个对象都只有一个”锁”，这就表明如果两个线程执行一个对象的两个不同的同步方法时，会发生”死锁”。即使这两个方法并不共享任何资源。为了避免这个问题，可以对一个对象实行”多锁”的机制。如下所示： class foo { private static int var1; private static Object lock1=new Object(); private static int var2; private static Object lock2=new Object(); public static void increment1() { synchronized(lock1) { var1++; } } public static void increment2() { synchronized(lock2) { var2++; } } } 4．输入和输出(I/O) 输入和输出包括很多方面，但涉及最多的是对硬盘，网络或数据库的读写操作。对于读写操作，又分为有缓存和没有缓存的；对于数据库的操作，又可以有多种类型的JDBC驱动器可以选择。但无论怎样，都会给程序的性能带来影响。因此，需要注意如下几点： (1) 使用输入输出缓冲 尽可能的多使用缓存。但如果要经常对缓存进行刷新（flush）,则建议不要使用缓存。 (2) 输出流(Output Stream)和Unicode字符串 当时用Output Stream和Unicode字符串时，Write类的开销比较大。因为它要实现Unicode到字节(byte)的转换.因此，如果可能的话,在使用Write类之前就实现转换或用OutputStream类代替Writer类来使用。 (3) 当需序列化时使用transient 当序列化一个类或对象时，对于那些原子类型（atomic）或可以重建的原素要表识为transient类型。这样就不用每一次都进行序列化。如果这些序列化的对象要在网络上传输，这一小小的改变对性能会有很大的提高。 (4) 使用高速缓存（Cache） 对于那些经常要使用而又不大变化的对象或数据，可以把它存储在高速缓存中。这样就可以提高访问的速度。这一点对于从数据库中返回的结果集尤其重要。 (5) 使用速度快的JDBC驱动器（Driver） JAVA对访问数据库提供了四种方法。这其中有两种是JDBC驱动器。一种是用JAVA外包的本地驱动器；另一种是完全的JAVA驱动器。具体要使用哪一种得根据JAVA布署的环境和应用程序本身来定。 5.一些其他的经验和技巧 (1) 使用局部变量 (2) 避免在同一个类中动过调用函数或方法(get或set)来设置或调用变量。 (3) 避免在循环中生成同一个变量或调用同一个函数（参数变量也一样） (4) 尽可能的使用static,final,private等关键字 (5) 当复制大量数据时，使用System.arraycopy()命令。
public static String replace( String value, String key, String replaceValue) {
if (value == null || key == null || replaceValue == null) {
return value; }int pos = value.indexOf(key);
if (pos < 0) {
return value; }int length = value.length();
int start = pos; int end = pos + key.length();if (length == key.length()) {
value = replaceValue;} else if (end == length) {
value = value.substring(0, start) + replaceValue;} else {
value = value.substring(0, start) + replaceValue + replace(value.substring(end), key, replaceValue); }return value;
} 发现没有，前面的if..else if完全可以作为最后一个else来操作，但是为什么，因为可能要多执行一次replace递归调用，这是从validator源码里面看见的，在来一段： if (log.isDebugEnabled()) { log.debug(" Looking for Action instance for class " + className); } 为什么还要判断是不是debug,不是假如配置成debug以上的，debug信息也不会输出吗，但是，记住，信息是不会输出，但是" Looking for Action instance for class " + className这条语句总要执行吧，就一个简单的boolean判断，就可以减少字符串相加的运算。所以优化性能，不能靠长篇大论，而是从小事抓起，从实际应用中和前辈代码中发现，总结
要记着尽量的缓存，如代码：
protected Method getMethod(String name) throws NoSuchMethodException {synchronized(methods) {
Method method = (Method) methods.get(name); if (method == null) { method = clazz.getMethod(name, types); methods.put(name, method); } return (method); }}
这是struts中一段使用反射得到方法的代码在J2EE的实际开发中，在request,session中都最好不要存储大对象，而应该是存储小对象，最应该避免的是list里面存储list这些操作，不仅代码不好看，难懂。因为有些服务器将session中的信息要存储在数据库中，如weblogic经过配置就可以将信息存在内存或是数据库中，假如是存储的大对象，那么假如你修改了一个属性以后，在调用setAttribute操作，此时服务器将大对象存储起来是很费时的一件事，还有就是假如在集群中发布的话，那么里
面存储的内容假如过多，在集群中同步也是很费时的操作
只在确实有必要做缓存的情况下才做缓存。。而不是 “要记着尽量的缓存”
随着jvm的发展,现在的jvm一般是采用分代式的垃圾收集机制,会分为小规模的 垃圾收集(只占用较少的CPU时间),大规模的垃圾收集(占用大量的CPU时间) 那么最好的情况是实例化一个对象不久，在引用过期后马上被收集掉 如果做了不必要的cache,则JVM必须花费大量的CPU时间在收集被缓存的堆对象..的确是这样的，当然假如没有必要那么肯定是不用做缓存的了，但是如上面我贴的那段代码，忘了到底是出出自struts还是validator,想这种分布式的应用程序，在网络上可能有很多人在调用，而struts又是使用前端控制器，那么缓存这个这个类的某些方法那么就是非常必要的了，因为反射本来就是一个相对比较好时的操作，那么假如每个请求都是重新得到Method对象肯定是效率低下的
想上面的这种缓存一般最大用途是在分布式里面，并且这些实例是所有用户共享的，假如是单个用户的话，那么实际意义倒还是不大
/**
* 名字相同即相同 */ public boolean equals(Object object) { return object instanceof Column && equals( (Column) object ); }/**
* 名字相同即相同 * @param column * @return */ public boolean equals(Column column) { if (null == column) return false; if (this == column) return true;return name.equals(column.name);
} 这段代码不错，以前实现的都是： if(object instanceof Column){ Column column=(Column)object; column.... } 但是假如按照最前面的写法，那么判断类型的那一步jvm就做判断了 效率提高的不是很多，执行1000000次也才是6倍而已/*
* Created on 2004-12-17 * * TODO To change the template for this generated file go to * Window - Preferences - Java - Code Style - Code Templates */ package temp;/**
* @author xinli * * TODO To change the template for this generated type comment go to * Window - Preferences - Java - Code Style - Code Templates */ public class Test {public static void main(String[] args) {
Test test=new Test(); A a=new B(); B b=(B)a; test.a(b); test.a(a);C c=new D();
D d=(D)c; test.c(c); test.c(d); } public void a(A a){ System.out.println("a(A)"); } public void a(B b){ System.out.println("a(B)"); } public void c(C c){ System.out.println("c(C)"); } public void c(D d){ System.out.println("c(D)"); } } class A{}
class B extends A{}
interface C{}
class D implements C{}
运行结果是： a(B) a(A) c(C) c(D) 怎么在继承关系上没有重载的概念呢？搞了两年多java了，今天才发现推荐文章
JSP/Servlet应用程序优化八法 [转贴] 原文 http://blog.csdn.net/liujun999999/archive/2004/12/23/226958.aspx在本文中，我将带领你学习已经实践和得到证实的性能调整技术，它将大大地提高你的servlet和jsp页面的性能，进而提升J2EE的性能。这些技术的部分用于开发阶段，例如，设计和编码阶段。另一部分技术则与配置相关。
技术1：在HttpServletinit()方法中缓存数据 服务器会在创建servlet实例之后和servlet处理任何请求之前调用servlet的init()方法。该方法在servlet的生命周期中仅调用一次。为了提高性能，在init()中缓存静态数据或完成要在初始化期间完成的代价昂贵的操作。例如，一个最佳实践是使用实现了javax.sql.DataSource接口的JDBC连接池。DataSource从JNDI树中获得。每调用一次SQL就要使用JNDI查找DataSource是非常昂贵的工作，而且严重影响了应用的性能。Servlet的init()方法可以用于获取DataSource并缓存它以便之后的重用：
publicclassControllerServletextendsHttpServlet { privatejavax.sql.DataSourcetestDS=null;publicvoidinit(ServletConfigconfig)throwsServletException
{ super.init(config); Contextctx=null; try { ctx=newInitialContext(); testDS=(javax.sql.DataSource)ctx.lookup("jdbc/testDS"); } catch(NamingExceptionne) { ne.printStackTrace(); } catch(Exceptione) { e.printStackTrace(); } }publicjavax.sql.DataSourcegetTestDS()
{ returntestDS; } ... ... } 技术2：禁用servlet和Jsp的自动装载功能 当每次修改了Servlet/JSP之后，你将不得不重新启动服务器。由于自动装载功能减少开发时间，该功能被认为在开发阶段是非常有用的。但是，它在运行阶段是非常昂贵的；servlet/JSP由于不必要的装载，增加类装载器的负担而造成很差的性能。同样，这会使你的应用由于已被某种类装载器装载的类不能和当前类装载器装载的类不能相互协作而出现奇怪的冲突现象。因此，在运行环境中为了得到更好的性能，关闭servlet/JSP的自动装载功能。技术3：控制HttpSession
许多应用需要一系列客户端的请求，因此他们能互相相关联。由于HTTP协议是无状态的，所以基于Web的应用需要负责维护这样一个叫做session的状态。为了支持必须维护状态的应用，Javaservlet技术提供了管理session和允许多种机制实现session的API。HttpSession对象扮演了session，但是使用它需要成本。无论何时HttpSession被使用和重写，它都由servlet读龋你可以通过使用下面的技术来提高性能： l在JSP页面中不要创建默认的HttpSession:默认情况下，JSP页面创建HttpSession。如果你在JSP页面中不用HttpSession，为了节省性能开销，使用下边的页面指令可以避免自动创建HttpSession对象： ＜%@pagesession="false"%＞1) 不要将大的对象图存储在HttpSession中：如果你将数据当作一个大的对象图存储在HttpSession中，应用服务器每次将不得不处理整个HttpSession对象。这将迫使Java序列化和增加计算开销。由于序列化的开销，随着存储在HttpSession对象中数据对象的增大，系统的吞吐量将会下降。
2) 用完后释放HttpSession：当不在使用HttpSession时，使用HttpSession.invalidate()方法使sesion失效。
3) 设置超时值：一个servlet引擎有一个默认的超时值。如果你不删除session或者一直把session用到它超时的时候，servlet引擎将把session从内存中删除。由于在内存和垃圾收集上的开销，session的超时值越大，它对系统弹性和性能的影响也越大。试着将session的超时值设置的尽可能低。
技术4：使用gzip压缩
压缩是删除冗余信息的作法，用尽可能小的空间描述你的信息。使用gzip（GNUzip）压缩文档能有效地减少下载HTML文件的时间。你的信息量越小，它们被送出的速度越快。因此，如果你压缩了由你web应用产生的内容，它到达用户并显示在用户屏幕上的速度就越快。不是任何浏览器都支持gzip压缩的，但检查一个浏览器是否支持它并发送gzip压缩内容到浏览器是很容易的事情。下边的代码段说明了如何发送压缩的内容。
publicvoiddoGet(HttpServletRequestrequest,HttpServletResponseresponse)
throwsIOException,ServletException {OutputStreamout=null
//ChecktheAccepting-EncodingheaderfromtheHTTPrequest.
//Iftheheaderincludesgzip,chooseGZIP. //Iftheheaderincludescompress,chooseZIP. //Otherwisechoosenocompression.Stringencoding=request.getHeader("Accept-Encoding");
if(encoding!=null&&encoding.indexOf("gzip")!=-1)
{ response.setHeader("Content-Encoding","gzip"); out=newGZIPOutputStream(response.getOutputStream()); } elseif(encoding!=null&&encoding.indexOf("compress")!=-1) { response.setHeader("Content-Encoding","compress"); out=newZIPOutputStream(response.getOutputStream()); } else { out=response.getOutputStream();}
... ... } 技术5：不要使用SingleThreadModelSingleThreadModel保证servlet一次仅处理一个请求。如果一个servlet实现了这个接口，servlet引擎将为每个新的请求创建一个单独的servlet实例，这将引起大量的系统开销。如果你需要解决线程安全问题，请使用其他的办法替代这个接口。SingleThreadModel在Servlet2.4中是不再提倡使用。
技术6：使用线程池
servlet引擎为每个请求创建一个单独的线程，将该线程指派给service()方法，然后在service()方法执行完后删除该线程。默认情况下，servlet引擎可能为每个请求创建一个新的线程。由于创建和删除线程的开销是很昂贵的，于是这种默认行为降低了系统的性能。我们可以使用线程池来提高性能。根据预期的并发用户数量，配置一个线程池，设置好线程池里的线程数量的最小和最大值以及增长的最小和最大值。起初，servlet引擎创建一个线程数与配置中的最小线程数量相等的线程池。然后servlet引擎把池中的一个线程指派给一个请求而不是每次都创建新的线程，完成操作之后，servlet引擎把线程放回到线程池中。使用线程池，性能可以显著地提高。如果需要，根据线程的最大数和增长数，可以创建更多的线程。
技术7：选择正确的包括机制
在JSP页面中，有两中方式可以包括文件：包括指令(＜%@includefile="test.jsp"%＞)和包括动作(＜jsp:includepage="test.jsp"flush="true"/＞)。包括指令在编译阶段包括一个指定文件的内容；例如，当一个页面编译成一个servlet时。包括动作是指在请求阶段包括文件内容；例如，当一个用户请求一个页面时。包括指令要比包括动作快些。因此除非被包括的文件经常变动，否则使用包括指令将会获得更好的性能。
技术8：在useBean动作中使用合适的范围
使用JSP页面最强大方式之一是和JavaBean组件协同工作。JavaBean使用＜jsp:useBean＞标签可以嵌入到JSP页面中。语法如下：
＜jsp:useBeanid="name"scope="page|request|session|application"class= "package.className"type="typeName"＞ ＜/jsp:useBean＞ scope属性说明了bean的可见范围。scope属性的默认值是page。你应该根据你应用的需求选择正确的范围，否则它将影响应用的性能。例如，如果你需要一个专用于某些请求的对象，但是你把范围设置成了session，那么那个对象将在请求结束之后还保留在内存中。它将一直保留在内存中除非你明确地把它从内存中删除、使session无效或session超时。如果你没有选择正确的范围属性，由于内存和垃圾收集的开销将会影响性能。因此为对象设置合适的范围并在用完它们之后立即删除。
杂项技术
1) 避免字符串连接：由于String对象是不可变对象，使用“＋”操作符将会导致创建大量的零时对象。你使用的“＋”越多，产出的零时对象就越多，这将影响性能。当你需要连接字符串时，使用StringBuffer替代“＋”操作。
2) 避免使用System.out.println：System.out.println同步处理磁盘输入/输出，这大大地降低了系统吞吐量。尽可能地避免使用System.out.println。尽管有很多成熟的调试工具可以用，但有时System.out.println为了跟踪、或调试的情况下依然很有用。你应该配置System.out.println仅在错误和调试阶段打开它。使用finalBoolean型的变量，当配置成false时，在编译阶段完成优化检查和执行跟踪输出。
3) ServletOutputStream与PrintWriter比较：由于字符输出流和把数据编码成字节，使用PrintWriter引入了小的性能开销。因此，PrintWriter应该用在所有的字符集都正确地转换做完之后。另一方面，当你知道你的servlet仅返回二进制数据，使用ServletOutputStream，因为servlet容器不编码二进制数据，这样你就能消除字符集转换开销。
总结
本文的目的是展示给你一些实践的和已经证实的用于提高servlet和JSP性能的性能优化技术，这些将提高你的J2EE应用的整体性能。下一步应该观察其他相关技术的性能调整，如EJB、JMS和JDBC等。