| 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程序中經常存在的性能瓶頸。 |
|
|
| 瞭解了這些瓶頸後，就可以有針對性的減少這些瓶頸，從而提高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的技術所執行。這些技術主要分爲兩個大類。即基於解釋的技術和基於提前編譯爲本地碼的技術。其示意圖如下： |
|
|
| 具體可分爲如下的五類： |
| a) 解釋指令技術 |
| 其結構圖和執行過程如下： |
|
|
| JAVA的編譯器首先把JAVA源文件編譯爲字節碼。這些字節碼對於JAVA虛擬機(JVM)來講就是機器的指令碼。然後，JAVA的解釋器不斷的循環取出字節碼進行解釋並執行。 |
| 這樣做的優點是可以實現JAVA語言的跨平臺，同時生成的字節碼也比較緊湊。JAVA的一些優點，如安全性，動態性都得保持；但缺點是省生成的字節碼沒有經過什麼優化，同全部編譯好的本地碼相比，速度比較慢。 |
| b) 及時編譯技術（Just In Time） |
| 及時編譯技術是爲了解決指令解釋技術效率比較低，速度比較慢的情況下提出的，其結構圖如下所示。 |
|
|
| 其主要變化是在JAVA程序執行之前，又JIT編譯器把JAVA的字節碼編譯爲機器碼。從而在程序運行時直接執行機器碼，而不用對字節碼進行解釋。同時對代碼也進行了部分的優化。 |
| 這樣做的優點是大大提高了JAVA程序的性能。同時，由於編譯的結果並不在程序運行間保存，因此也節約了存儲空間了加載程序的時間；缺點是由於JIT編譯器對所有的代碼都想優化，因此也浪費了很多的時間。 |
| IBM和SUN公司都提供了相關的JIT產品。 |
| c) 適應性優化技術（Adaptive Optimization Technology） |
| 同JIT技術相比，適應性優化技術並不對所有的字節碼進行優化。它會跟蹤程序運行的成個過程，從而發現需要優化的代碼，對代碼進行動態的優化。對優化的代碼，採取80/20的策略。從理論上講，程序運行的時間越長，代碼就越優化。其結構圖如下： |
|
|
| 其優點是適應性優化技術充分利用了程序執行時的信息，發行程序的性能瓶頸，從而提高程序的性能；其缺點是在進行優化時可能會選擇不當，發而降低了程序的性能。 |
| 其主要產品又IBM,SUN的HotSpot. |
| d) 動態優化，提前編譯爲機器碼的技術（Dynamic Optimization,Ahead Of Time） |
| 動態優化技術充分利用了JAVA源碼編譯，字節碼編譯，動態編譯和靜態編譯的技術。其輸入時JAVA的原碼或字節碼，而輸出是經過高度優化的可執行代碼和個來動態庫的混合(Window中是DLL文件，UNIX中是共享庫.a .so文件)。其結構如下： |
|
|
| 其優點是能大大提高程序的性能；缺點是破壞了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 * * * * * * * * * * * * * * * * */ |
| 測試的結果如下（假設標準的時間爲１，越小性能越好）： |
|
|
| 關於線程的操作，要注意如下幾個方面。 |
| (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()命令。 |