1. 程式人生 > >巢狀For迴圈效能優化案例

巢狀For迴圈效能優化案例

1 案例描述 
某日,在JavaEye上看到一道面試題,題目是這樣的:請對以下的程式碼進行優化 
Java程式碼  收藏程式碼
  1. for (int i = 0; i < 1000; i++)  
  2.     for (int j = 0; j < 100; j++)  
  3.         for (int k = 0; k < 10; k++)  
  4.             testFunction (i, j, k);  

(注:為了同後面的內容一致,這裡對原題目進行了部分修改) 

2 案例分析 
從給出的程式碼可知,不論如何優化,testFunction執行的次數都是相同的,該部分不存在優化的可能。那麼,程式碼的優化只能從迴圈變數i、j、k的例項化、初始化、比較、自增等方面的耗時上進行分析。 
首先,我們先分析原題程式碼迴圈變數在例項化、初始化、比較、自增等方面的耗時情況: 
變數 例項化(次數) 初始化(次數) 比較(次數) 自增(次數)
i 1 1 1000 1000
j 1000 1000 1000 * 100 1000 * 100
k 1000 * 100 1000 * 100 1000 * 100 * 10 1000 * 100 * 10

(注:由於單次耗時視不同機器配置而不同,上表相關耗時採用處理的次數進行說明) 
該程式碼的效能優化就是儘可能減少迴圈變數i、j、k的例項化、初始化、比較、自增的次數,同時,不能引進其它可能的運算耗時。 

3 解決過程 
從案例分析,對於原題程式碼,我們提出有兩種優化方案: 
3.1 優化方案一 
程式碼如下: 
Java程式碼  收藏程式碼
  1. for (int i = 0; i < 10; i++)  
  2.     for
     (int j = 0; j < 100; j++)  
  3.         for (int k = 0; k < 1000; k++)  
  4.             testFunction (k, j, i);  

該方案主要是將迴圈次數最少的放到外面,迴圈次數最多的放裡面,這樣可以最大程度的(注:3個不同次數的迴圈變數共有6種排列組合情況,此種組合為最優)減少相關迴圈變數的例項化次數、初始化次數、比較次數、自增次數,方案耗時情況如下: 
變數 例項化(次數) 初始化(次數) 比較(次數) 自增(次數)
i 1 1 10 10
j 10 10 10 * 100 10 * 100
k 10 * 100 10 * 100 10 * 100 * 1000 10 * 100 * 1000


3.2 優化方案二 
程式碼如下: 
Java程式碼  收藏程式碼
  1. int i, j, k;  
  2. for (i = 0; i < 10; i++)  
  3.     for (j = 0; j < 100; j++)  
  4.         for (k = 0; k < 1000; k++)  
  5.             testFunction (k, j, i);  

該方案在方案一的基礎上,將迴圈變數的例項化放到迴圈外,這樣可以進一步減少相關迴圈變數的例項化次數,方案耗時情況如下: 
變數 例項化(次數) 初始化(次數) 比較(次數) 自增(次數)
i 1 1 10 10
j 1 10 10 * 100 10 * 100
k 1 10 * 100 10 * 100 * 1000 10 * 100 * 1000


4 解決結果 
那麼,提出的優化方案是否如我們分析的那樣有了效能上的提升了呢?我們編寫一些測試程式碼進行驗證,資料更能說明我們的優化效果。 
4.1 測試程式碼 
Java程式碼  收藏程式碼
  1. public static void testFunction(int i, int j, int k) {  
  2.         System.out.print("");   // 注:該方法不影響整體優化,這裡只有簡單輸出  
  3.     }  
  4.     public static void testA() {  
  5.         long start = System.nanoTime();  
  6.         for (int i = 0; i < 1000; i++)  
  7.             for (int j = 0; j < 100; j++)  
  8.                 for (int k = 0; k < 10; k++)  
  9.                     testFunction(i, j, k);  
  10.         System.out.println("testA time>>" + (System.nanoTime() - start));  
  11.     }  
  12.     public static void testB() {  
  13.         long start = System.nanoTime();  
  14.         for (int i = 0; i < 10; i++)  
  15.             for (int j = 0; j < 100; j++)  
  16.                 for (int k = 0; k < 1000; k++)  
  17.                     testFunction(k, j, i);  
  18.         System.out.println("testB time>>" + (System.nanoTime() - start));  
  19.     }  
  20.     public static void testC() {  
  21.         long start = System.nanoTime();  
  22.         int i;  
  23.         int j;  
  24.         int k;  
  25.         for (i = 0; i < 10; i++)  
  26.             for (j = 0; j < 100; j++)  
  27.                 for (k = 0; k < 1000; k++)  
  28.                     testFunction(k, j, i);  
  29.         System.out.println("testC time>>" + (System.nanoTime() - start));  
  30. }  

4.2 測試結果 
1、測試機器配置:Pentium(R) Dual-Core CPU E5400 @2.70GHz 2.70GHz, 2GB記憶體; 
2、迴圈變數i、j、k迴圈次數分別為10、100、1000,進行5組測試,測試結果如下: 
第1組 第2組 第3組 第4組 第5組
原方案 171846271 173250166 173910870 173199875 173725328
方案一 168839312 168466660 168372616 168310190 168041251
方案二 168001838 169141906 168230655 169421766 168240748

從上面的測試結果來看,優化後的方案明顯效能優於原方案,達到了優化的效果。但優化方案二並沒有如我們預期的優於方案一,其中第2、4、5組的資料更是比方案一差,懷疑可能是迴圈次數太少,以及測試環境相關因素影響下出現的結果。 

3、重新調整迴圈變數i、j、k迴圈次數分別為20、200、2000,進行5組測試,測試結果如下: 
第1組 第2組 第3組 第4組 第5組
原方案 1355397203 1358978176 1358128281 1350193682 1354786598
方案一 1343482704 1348410388 1343978037 1347919156 1340697793
方案二 1342427528 1343897887 1342662462 1342124048 1336266453

從上面的測試結果來看,優化後的方案基本符合我們的預期結果。 

5 總結 
從案例分析和解決過程中的三個表的分析可知,優化方案一和優化方案二的效能都比原始碼的效能好,其中優化方案二的效能是最好的。在巢狀For迴圈中,將迴圈次數多的迴圈放在內側,迴圈次數少的迴圈放在外側,其效能會提高;減少迴圈變數的例項化,其效能也會提高。從測試資料可知,對於兩種優化方案,如果在迴圈次數較少的情況下,其執行效果區別不大;但在迴圈次數較多的情況下,其效果就比較明顯了。 

6 參考資料 
[1] http://www.javaeye.com/topic/762312 
[2] http://www.javaeye.com/topic/632481