通过使用一些辅助性工具来找到程序中的瓶颈然后就可以对瓶颈部分的代码进行优化一般有两种方案即优化代码或更改设计方法我们一般会选择后者因为不去调用以下代码要比调用一些优化的代码更能提高程序的性能而一个设计良好的程序能够精简代码从而提高性能
下面将提供一些在JAVA程序的设计和编码中为了能够提高JAVA程序的性能而经常采用的一些方法和技巧
．对象的生成和大小的调整
JAVA程序设计中一个普遍的问题就是没有好好的利用JAVA语言本身提供的函数从而常常会生成大量的对象（或实例）由于系统不仅要花时间生成对象以后可能还需花时间对这些对象进行垃圾回收和处理因此生成过多的对象将会给程序的性能带来很大的影响
例关于String StringBuffer+和append
JAVA语言提供了对于String类型变量的操作但如果使用不当会给程序的性能带来影响如下面的语句
String name=new String(HuangWeiFeng);
Systemoutprintln(name+is my name);
看似已经很精简了其实并非如此为了生成二进制的代码要进行如下的步骤和操作
() 生成新的字符串 new String（STR_);
() 复制该字符串;
() 加载字符串常量HuangWeiFeng（STR_);
() 调用字符串的构架器（Constructor）;
() 保存该字符串到数组中（从位置开始）;
() 从javaioPrintStream类中得到静态的out变量;
() 生成新的字符串缓沖变量new StringBuffer(STR_BUF_);
() 复制该字符串缓沖变量;
() 调用字符串缓沖的构架器（Constructor）;
() 保存该字符串缓沖到数组中（从位置开始）;
() 以STR_为参数调用字符串缓沖(StringBuffer)类中的append方法;
() 加载字符串常量is my name(STR_);
() 以STR_为参数调用字符串缓沖(StringBuffer)类中的append方法;
() 对于STR_BUF_执行toString命令;
() 调用out变量中的println方法输出结果
由此可以看出这两行简单的代码就生成了STR_STR_STR_STR_和STR_BUF_五个对象变量这些生成的类的实例一般都存放在堆中堆要对所有类的超类类的实例进行初始化同时还要调用类极其每个超类的构架器而这些操作都是非常消耗系统资源的因此对对象的生成进行限制是完全有必要的
经修改上面的代码可以用如下的代码来替换
StringBuffer name=new StringBuffer(HuangWeiFeng);
Systemoutprintln(nameappend(is my name)toString());
系统将进行如下的操作
() 生成新的字符串缓沖变量new StringBuffer(STR_BUF_);
() 复制该字符串缓沖变量;
() 加载字符串常量HuangWeiFeng(STR_);
() 调用字符串缓沖的构架器（Constructor）;
() 保存该字符串缓沖到数组中（从位置开始）;
() 从javaioPrintStream类中得到静态的out变量;
() 加载STR_BUF_;
() 加载字符串常量is my name(STR_);
() 以STR_为参数调用字符串缓沖(StringBuffer)实例中的append方法;
() 对于STR_BUF_执行toString命令(STR_);
()调用out变量中的println方法输出结果
由此可以看出经过改进后的代码只生成了四个对象变量STR_STR_STR_和STR_BUF_你可能觉得少生成一个对象不会对程序的性能有很大的提高但下面的代码段的执行速度将是代码段的倍因为代码段生成了八个对象而代码段只生成了四个对象
代码段
String name= new StringBuffer(HuangWeiFeng);
name+=is my;
name+=name;
代码段
StringBuffer name=new StringBuffer(HuangWeiFeng);
nameappend(is my);
nameappend(name)toString();
因此充分的利用JAVA提供的库函数来优化程序对提高JAVA程序的性能时非常重要的其注意点主要有如下几方面
() 尽可能的使用静态变量（Static Class Variables）
如果类中的变量不会随他的实例而变化就可以定义为静态变量从而使他所有的实例都共享这个变量
例
public class foo
{
SomeObject so=new SomeObject();
}
就可以定义为
public class foo
{
static SomeObject so=new SomeObject();
}
() 不要对已生成的对象作过多的改变
对于一些类(如String类)来讲宁愿在重新生成一个新的对象实例而不应该修改已经生成的对象实例
例
String name=Huang;
name=Wei;
name=Feng;
上述代码生成了三个String类型的对象实例而前两个马上就需要系统进行垃圾回收处理如果要对字符串进行连接的操作性能将得更差因为系统将不得为此生成更多得临时变量如上例所示
() 生成对象时要分配给它合理的空间和大小JAVA中的很多类都有它的默认的空间分配大小对于StringBuffer类来讲默认的分配空间大小是个字符如果在程序中使用StringBuffer的空间大小不是个字符那么就必须进行正确的初始化
() 避免生成不太使用或生命周期短的对象或变量对于这种情况因该定义一个对象缓沖池以为管理一个对象缓沖池的开销要比频繁的生成和回收对象的开销小的多
() 只在对象作用范围内进行初始化JAVA允许在代码的任何地方定义和初始化对象这样就可以只在对象作用的范围内进行初始化从而节约系统的开销
例
SomeObject so=new SomeObject();
If(x==) then
{
Foo=sogetXX();
}
可以修改为
if(x==) then
{
SomeObject so=new SomeObject();
Foo=sogetXX();
}
．异常(Exceptions)
JAVA语言中提供了try/catch来发方便用户捕捉异常进行异常的处理但是如果使用不当也会给JAVA程序的性能带来影响因此要注意以下两点
() 避免对应用程序的逻辑使用try/catch
如果可以用ifwhile等逻辑语句来处理那么就尽可能的不用try/catch语句
() 重用异常
在必须要进行异常的处理时要尽可能的重用已经存在的异常对象以为在异常的处理中生成一个异常对象要消耗掉大部分的时间
线程(Threading)
一个高性能的应用程序中一般都会用到线程因为线程能充分利用系统的资源在其他线程因为等待硬盘或网络读写而 时程序能继续处理和运行但是对线程运用不当也会影响程序的性能
例正确使用Vector类
Vector主要用来保存各种类型的对象（包括相同类型和不同类型的对象）但是在一些情况下使用会给程序带来性能上的影响这主要是由Vector类的两个特点所决定的第一Vector提供了线程的安全保护功能即使Vector类中的许多方法同步但是如果你已经确认你的应用程序是单线程这些方法的同步就完全不必要了第二在Vector查找存储的各种对象时常常要花很多的时间进行类型的匹配而当这些对象都是同一类型时这些匹配就完全不必要了因此有必要设计一个单线程的保存特定类型对象的类或集合来替代Vector类用来替换的程序如下（StringVectorjava）
public class StringVector
{
private String [] data;
private int count;
public StringVector()
{
this(); // default size is
}
public StringVector(int initialSize)
{
data = new String[initialSize];
}
public void add(String str)
{
// ignore null strings
if(str == null) { return; }
ensureCapacity(count + );
data[count++] = str;
}
private void ensureCapacity(int minCapacity)
{
int oldCapacity = datalength;
if (minCapacity > oldCapacity)
{
String oldData[] = data;
int newCapacity = oldCapacity * ;
data = new String[newCapacity];
Systemarraycopy(oldData data count);
}
}
public void remove(String str)
{
if(str == null) { return; // ignore null str }
for(int i = ; i < count; i++)
{
// check for a match
if(data[i]equals(str))
{
Systemarraycopy(datai+dataicount); // copy data
// allow previously valid array element be gc?d
data[count] = null;
return;
}
}
}
public final String getStringAt(int index)
{
if(index < ) { return null; }
else if(index > count) { return null; // index is > # strings }
else { return data[index]; // index is good }
}
}
因此代码
Vector Strings=new Vector();
Stringsadd(One);
Stringsadd(Two);
String Second=(String)StringselementAt();
可以用如下的代码替换
StringVector Strings=new StringVector();
Stringsadd(One);
Stringsadd(Two);
String Second=StringsgetStringAt();
这样就可以通过优化线程来提高JAVA程序的性能用于测试的程序如下（TestCollectionjava）:
import javautilVector;
public class TestCollection
{
public static void main(String args [])
{
TestCollection collect = new TestCollection();
if(argslength == )
{
Systemoutprintln(Usage: java TestCollection [ vector | stringvector ]);
Systemexit();
}
if(args[]equals(vector))
{
Vector store = new Vector();
long start = SystemcurrentTimeMillis();
for(int i = ; i < ; i++)
{
storeaddElement(string);
}
long finish = SystemcurrentTimeMillis();
Systemoutprintln((finishstart));
start = SystemcurrentTimeMillis();
for(int i = ; i < ; i++)
{
String result = (String)storeelementAt(i);
}
finish = SystemcurrentTimeMillis();
Systemoutprintln((finishstart));
}
else if(args[]equals(stringvector))
{
StringVector store = new StringVector();
long start = SystemcurrentTimeMillis();
for(int i = ; i < ; i++) { storeadd(string); }
long finish = SystemcurrentTimeMillis();
Systemoutprintln((finishstart));
start = SystemcurrentTimeMillis();
for(int i = ; i < ; i++) {
String result = storegetStringAt(i);
}
finish = SystemcurrentTimeMillis();
Systemoutprintln((finishstart));
}
}
}
关于线程的操作要注意如下几个方面
() 防止过多的同步
如上所示不必要的同步常常会造成程序性能的下降因此如果程序是单线程则一定不要使用同步
() 同步方法而不要同步整个代码段
对某个方法或函数进行同步比对整个代码段进行同步的性能要好
() 对每个对象使用多锁的机制来增大并发
一般每个对象都只有一个锁这就表明如果两个线程执行一个对象的两个不同的同步方法时会发生死锁即使这两个方法并不共享任何资源为了避免这个问题可以对一个对象实行多锁的机制如下所示
class foo
{
private static int var;
private static Object lock=new Object();
private static int var;
private static Object lock=new Object();
public static void increment()
{
synchronized(lock)
{
var++;
}
}
public static void increment()
{
synchronized(lock)
{
var++;
}
}
}
．输入和输出(I/O)
输入和输出包括很多方面但涉及最多的是对硬盘网络或数据库的读写操作对于读写操作又分为有缓存和没有缓存的对于数据库的操作又可以有多种类型的JDBC驱动器可以选择但无论怎样都会给程序的性能带来影响因此需要注意如下几点
() 使用输入输出缓沖
尽可能的多使用缓存但如果要经常对缓存进行刷新（flush）则建议不要使用缓存
() 输出流(Output Stream)和Unicode字符串
当时用Output Stream和Unicode字符串时Write类的开销比较大因为它要实现Unicode到字节(byte)的转换因此如果可能的话在使用Write类之前就实现转换或用OutputStream类代替Writer类来使用
() 当需序列化时使用transient
当序列化一个类或对象时对于那些原子类型（atomic）或可以重建的原素要表识为transient类型这样就不用每一次都进行序列化如果这些序列化的对象要在网络上传输这一小小的改变对性能会有很大的提高
() 使用高速缓存（Cache）
对于那些经常要使用而又不大变化的对象或数据可以把它存储在高速缓存中这样就可以提高访问的速度这一点对于从数据库中返回的结果集尤其重要
() 使用速度快的JDBC驱动器（Driver）
JAVA对访问数据库提供了四种方法这其中有两种是JDBC驱动器一种是用JAVA外包的本地驱动器另一种是完全的JAVA驱动器具体要使用哪一种得根据JAVA布署的环境和应用程序本身来定
一些其他的经验和技巧
() 使用局部变量
() 避免在同一个类中动过调用函数或方法(get或set)来设置或调用变量
() 避免在循环中生成同一个变量或调用同一个函数（参数变量也一样）
() 尽可能的使用staticfinalprivate等关键字
() 当复制大量数据时使用Systemarraycopy()命令
