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