通過使用一些輔助性工具來找到程序中的瓶頸，然后就可以對瓶頸部分的代碼進(jìn)行優(yōu)化。一般有兩種方案：即優(yōu)化代碼或更改設(shè)計方法。我們一般會選擇后者，因為不去調(diào)用以下代碼要比調(diào)用一些優(yōu)化的代碼更能提高程序的性能。而一個設(shè)計良好的程序能夠精簡代碼，從而提高性能。

下面將提供一些在JAVA程序的設(shè)計和編碼中，為了能夠提高JAVA程序的性能，而經(jīng)常采用的一些方法和技巧。

一、對象的生成和大小的調(diào)整。

JAVA程序設(shè)計中一個普遍的問題就是沒有好好的利用JAVA語言本身提供的函數(shù)，從而常常會生成大量的對象（或?qū)嵗?。由于系統(tǒng)不僅要花時間生成對象，以后可能還需花時間對這些對象進(jìn)行垃圾回收和處理。因此，生成過多的對象將會給程序的性能帶來很大的影響。

例1：關(guān)于String ,StringBuffer，+和append

JAVA語言提供了對于String類型變量的操作。但如果使用不當(dāng)，會給程序的性能帶來影響。如下面的語句：

String name=new String("HuangWeiFeng");   
System.out.println(name+"is my name");  

看似已經(jīng)很精簡了，其實(shí)并非如此。為了生成二進(jìn)制的代碼，要進(jìn)行如下的步驟和操作：

(1) 生成新的字符串 new String（STR_1);

(2) 復(fù)制該字符串;

(3) 加載字符串常量"HuangWeiFeng"（STR_2);

(4) 調(diào)用字符串的構(gòu)架器（Constructor）;

(5) 保存該字符串到數(shù)組中（從位置0開始）;

(6) 從java.io.PrintStream類中得到靜態(tài)的out變量;

(7) 生成新的字符串緩沖變量new StringBuffer(STR_BUF_1);

(8) 復(fù)制該字符串緩沖變量;

(9) 調(diào)用字符串緩沖的構(gòu)架器（Constructor）;

(10) 保存該字符串緩沖到數(shù)組中（從位置1開始）;

(11) 以STR_1為參數(shù)，調(diào)用字符串緩沖(StringBuffer)類中的append方法;

(12) 加載字符串常量"is my name"(STR_3);

(13) 以STR_3為參數(shù)，調(diào)用字符串緩沖(StringBuffer)類中的append方法;

(14) 對于STR_BUF_1執(zhí)行toString命令;

(15) 調(diào)用out變量中的println方法，輸出結(jié)果。

由此可以看出，這兩行簡單的代碼，就生成了STR_1,STR_2,STR_3,STR_4和STR_BUF_1五個對象變量。這些生成的類的實(shí)例一般都存放在堆中。堆要對所有類的超類，類的實(shí)例進(jìn)行初始化，同時還要調(diào)用類極其每個超類的構(gòu)架器。而這些操作都是非常消耗系統(tǒng)資源的。因此，對對象的生成進(jìn)行限制，是完全有必要的。

經(jīng)修改，上面的代碼可以用如下的代碼來替換。

StringBuffer name=new StringBuffer("HuangWeiFeng");   
System.out.println(name.append("is my name.").toString());  

系統(tǒng)將進(jìn)行如下的操作：

(1) 生成新的字符串緩沖變量new StringBuffer(STR_BUF_1);

(2) 復(fù)制該字符串緩沖變量;

(3) 加載字符串常量"HuangWeiFeng"(STR_1);

(4) 調(diào)用字符串緩沖的構(gòu)架器（Constructor）;

(5) 保存該字符串緩沖到數(shù)組中（從位置1開始）;

(6) 從java.io.PrintStream類中得到靜態(tài)的out變量;

(7) 加載STR_BUF_1;

(8) 加載字符串常量"is my name"(STR_2);

(9) 以STR_2為參數(shù)，調(diào)用字符串緩沖(StringBuffer)實(shí)例中的append方法;

(10) 對于STR_BUF_1執(zhí)行toString命令(STR_3);

(11)調(diào)用out變量中的println方法，輸出結(jié)果。

由此可以看出，經(jīng)過改進(jìn)后的代碼只生成了四個對象變量：STR_1,STR_2,STR_3和STR_BUF_1.你可能覺得少生成一個對象不會對程序的性能有很大的提高。但下面的代碼段2的執(zhí)行速度將是代碼段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提供的庫函數(shù)來優(yōu)化程序，對提高JAVA程序的性能時非常重要的.其注意點(diǎn)主要有如下幾方面：

(1) 盡可能的使用靜態(tài)變量（Static Class Variables）

如果類中的變量不會隨他的實(shí)例而變化，就可以定義為靜態(tài)變量，從而使他所有的實(shí)例都共享這個變量。

例：

public class foo   
{   
SomeObject so=new SomeObject();   
} 

就可以定義為：

public class foo   
{   
static SomeObject so=new SomeObject();   
}  

(2) 不要對已生成的對象作過多的改變。

對于一些類(如：String類)來講，寧愿在重新生成一個新的對象實(shí)例，而不應(yīng)該修改已經(jīng)生成的對象實(shí)例。

例：

String name="Huang";   
name="Wei";   
name="Feng"; 

上述代碼生成了三個String類型的對象實(shí)例。而前兩個馬上就需要系統(tǒng)進(jìn)行垃圾回收處理。如果要對字符串進(jìn)行連接的操作，性能將得更差，因為系統(tǒng)將不得為此生成更多得臨時變量，如上例1所示。

(3) 生成對象時，要分配給它合理的空間和大小JAVA中的很多類都有它的默認(rèn)的空間分配大小。對于StringBuffer類來講，默認(rèn)的分配空間大小是16個字符。如果在程序中使用StringBuffer的空間大小不是16個字符，那么就必須進(jìn)行正確的初始化。

(4) 避免生成不太使用或生命周期短的對象或變量。對于這種情況，因該定義一個對象緩沖池。以為管理一個對象緩沖池的開銷要比頻繁的生成和回收對象的開銷小的多。

(5) 只在對象作用范圍內(nèi)進(jìn)行初始化。JAVA允許在代碼的任何地方定義和初始化對象。這樣，就可以只在對象作用的范圍內(nèi)進(jìn)行初始化。從而節(jié)約系統(tǒng)的開銷。

例：

SomeObject so=new SomeObject();   
If(x==1) then   
{   
Foo=so.getXX();   
}  

可以修改為：

if(x==1) then   
{   
SomeObject so=new SomeObject();   
Foo=so.getXX();   
}  

二、異常(Exceptions)

JAVA語言中提供了try/catch來發(fā)方便用戶捕捉異常，進(jìn)行異常的處理。但是如果使用不當(dāng)，也會給JAVA程序的性能帶來影響。因此，要注意以下兩點(diǎn)：

(1) 避免對應(yīng)用程序的邏輯使用try/catch

如果可以用if,while等邏輯語句來處理，那么就盡可能的不用try/catch語句。

(2) 重用異常

在必須要進(jìn)行異常的處理時，要盡可能的重用已經(jīng)存在的異常對象。以為在異常的處理中，生成一個異常對象要消耗掉大部分的時間。

三、線程(Threading)

一個高性能的應(yīng)用程序中一般都會用到線程。因為線程能充分利用系統(tǒng)的資源。在其他線程因為等待硬盤或網(wǎng)絡(luò)讀寫而 時，程序能繼續(xù)處理和運(yùn)行。但是對線程運(yùn)用不當(dāng)，也會影響程序的性能。

例2：正確使用Vector類

Vector主要用來保存各種類型的對象（包括相同類型和不同類型的對象）。但是在一些情況下使用會給程序帶來性能上的影響。這主要是由Vector類的兩個特點(diǎn)所決定的。***，Vector提供了線程的安全保護(hù)功能。即使Vector類中的許多方法同步。但是如果你已經(jīng)確認(rèn)你的應(yīng)用程序是單線程，這些方法的同步就完全不必要了。第二，在Vector查找存儲的各種對象時，常常要花很多的時間進(jìn)行類型的匹配。而當(dāng)這些對象都是同一類型時，這些匹配就完全不必要了。因此，有必要設(shè)計一個單線程的，保存特定類型對象的類或集合來替代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 }   
}   
}  

因此，代碼：

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);  

這樣就可以通過優(yōu)化線程來提高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));   
}   
}   
}  

關(guān)于線程的操作，要注意如下幾個方面：

(1) 防止過多的同步

如上所示，不必要的同步常常會造成程序性能的下降。因此，如果程序是單線程，則一定不要使用同步。

(2) 同步方法而不要同步整個代碼段

對某個方法或函數(shù)進(jìn)行同步比對整個代碼段進(jìn)行同步的性能要好。

(3) 對每個對象使用多”鎖”的機(jī)制來增大并發(fā)。

一般每個對象都只有一個”鎖”，這就表明如果兩個線程執(zhí)行一個對象的兩個不同的同步方法時，會發(fā)生”死鎖”。即使這兩個方法并不共享任何資源。為了避免這個問題，可以對一個對象實(shí)行”多鎖”的機(jī)制。如下所示：

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++;   
}   
}   
}  

四、輸入和輸出(I/O)

輸入和輸出包括很多方面，但涉及最多的是對硬盤，網(wǎng)絡(luò)或數(shù)據(jù)庫的讀寫操作。對于讀寫操作，又分為有緩存和沒有緩存的；對于數(shù)據(jù)庫的操作，又可以有多種類型的JDBC驅(qū)動器可以選擇。但無論怎樣，都會給程序的性能帶來影響。因此，需要注意如下幾點(diǎn)：

(1) 使用輸入輸出緩沖

盡可能的多使用緩存。但如果要經(jīng)常對緩存進(jìn)行刷新（flush）,則建議不要使用緩存。

(2) 輸出流(Output Stream)和Unicode字符串

當(dāng)時用Output Stream和Unicode字符串時，Write類的開銷比較大。因為它要實(shí)現(xiàn)Unicode到字節(jié)(byte)的轉(zhuǎn)換.因此，如果可能的話,在使用Write類之前就實(shí)現(xiàn)轉(zhuǎn)換或用OutputStream類代替Writer類來使用。

(3) 當(dāng)需序列化時使用transient

當(dāng)序列化一個類或?qū)ο髸r，對于那些原子類型（atomic）或可以重建的原素要表識為transient類型。這樣就不用每一次都進(jìn)行序列化。如果這些序列化的對象要在網(wǎng)絡(luò)上傳輸，這一小小的改變對性能會有很大的提高。

(4) 使用高速緩存（Cache）

對于那些經(jīng)常要使用而又不大變化的對象或數(shù)據(jù)，可以把它存儲在高速緩存中。這樣就可以提高訪問的速度。這一點(diǎn)對于從數(shù)據(jù)庫中返回的結(jié)果集尤其重要。

(5) 使用速度快的JDBC驅(qū)動器（Driver）

JAVA對訪問數(shù)據(jù)庫提供了四種方法。這其中有兩種是JDBC驅(qū)動器。一種是用JAVA外包的本地驅(qū)動器；另一種是完全的JAVA驅(qū)動器。具體要使用哪一種得根據(jù)JAVA布署的環(huán)境和應(yīng)用程序本身來定。

五、一些其他的經(jīng)驗和技巧

(1) 使用局部變量。

(2) 避免在同一個類中動過調(diào)用函數(shù)或方法(get或set)來設(shè)置或調(diào)用變量。

(3) 避免在循環(huán)中生成同一個變量或調(diào)用同一個函數(shù)（參數(shù)變量也一樣）。

(4) 盡可能的使用static,final,private等關(guān)鍵字。

(5) 當(dāng)復(fù)制大量數(shù)據(jù)時，使用System.arraycopy()命令。

原文鏈接：http://blog.csdn.net/m13666368773/article/details/7249904

【編輯推薦】

1. 菜鳥入門Java語言學(xué)習(xí)的要點(diǎn)
2. 用Java實(shí)現(xiàn)的日志切割清理工具
3. Java自定義范型的應(yīng)用技巧
4. Java中Class對象詳解
5. Java API設(shè)計清單