嵌套For循環性能優化案例

1 案例描述 
某日，在JavaEye上看到一道面試題，題目是這樣的：請對以下的代碼進行優化 

for (int i = 0; i < 1000; i++)
    for (int j = 0; j < 100; j++)
        for (int k = 0; k < 10; k++)
            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 優化方案一 
代碼如下： 

for (int i = 0; i < 10; i++)
    for (int j = 0; j < 100; j++)
        for (int k = 0; k < 1000; k++)
            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 優化方案二 
代碼如下： 

int i, j, k;
for (i = 0; i < 10; i++)
    for (j = 0; j < 100; j++)
        for (k = 0; k < 1000; k++)
            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 測試代碼 

public static void testFunction(int i, int j, int k) {
        System.out.print("");   // 注：該方法不影響整體優化，這裏只有簡單輸出
    }

    public static void testA() {
        long start = System.nanoTime();
        for (int i = 0; i < 1000; i++)
            for (int j = 0; j < 100; j++)
                for (int k = 0; k < 10; k++)
                    testFunction(i, j, k);
        System.out.println("testA time>>" + (System.nanoTime() - start));
    }

    public static void testB() {
        long start = System.nanoTime();
        for (int i = 0; i < 10; i++)
            for (int j = 0; j < 100; j++)
                for (int k = 0; k < 1000; k++)
                    testFunction(k, j, i);
        System.out.println("testB time>>" + (System.nanoTime() - start));
    }

    public static void testC() {
        long start = System.nanoTime();
        int i;
        int j;
        int k;
        for (i = 0; i < 10; i++)
            for (j = 0; j < 100; j++)
                for (k = 0; k < 1000; k++)
                    testFunction(k, j, i);
        System.out.println("testC time>>" + (System.nanoTime() - start));
}

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循環中，將循環次數多的循環放在內側，循環次數少的循環放在外側，其性能會提高；減少循環變量的實例化，其性能也會提高。從測試數據可知，對於兩種優化方案，如果在循環次數較少的情況下，其運行效果區別不大；但在循環次數較多的情況下，其效果就比較明顯了。 

轉載：http://cgs1999.iteye.com/blog/1596671