迴圈比對條件的陣列長度該不該用變數?

前幾天看到關於陣列跑迴圈時,比對條件裡陣列長度改用變數提升執行效率的討論。亦即

for (int i = 0; i < array.Length; i++) ...

若改成

int c = array.Length;
for (int i = 0; i < c; i++) ...

會不會變快?

支持變快的理由是比對條件會反覆執行,array.Length透過屬性取值會比直接存取變數耗時。

但有另一派說法:

Some programmers believe that they can get a speed boost by moving the length calculation out and saving it to a temp, as in the example on the right.

The truth is, optimizations like this haven't been helpful for nearly 10 years: modern compilers are more than capable of performing this optimization for you. In fact, sometimes things like this can actually hurt performance. In the example above, a compiler would probably check to see that the length of myArray is constant, and insert a constant in the comparison of the for loop. But the code on the right might trick the compiler into thinking that this value must be stored in a register, since l is live throughout the loop. The bottom line is: write the code that's the most readable and that makes the most sense. It's not going to help to try to outthink the compiler, and sometimes it can hurt.

意思是,當代編譯器早非吳下阿蒙,面對這種情境能判斷array.Length不會變,JIT產生的執行碼在比對條件時會直接用常數;刻意改用變數,編譯器反而被誤道以為其值可能變化而改用Regiter儲存,效率反而較差。

兩派主張都有道理,那就實測看看好了。

寫了一支簡單測試程式,宣告一個由65535個int組成的陣列,分別存入0到65534,使用迴圈進行累加,因累加一輪時間太短,連續跑5000回合做為計時單位,等同執行約32憶次迴圈所耗時間。分別用for迴圈+array.Length、for迴圈+長度變數、foreach三種做法各測一次,另外怕只測一次數據會受其他因素干擾失真,故三種測試都跑100次求平均減少誤差。

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
 
namespace TestLoop
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] ary = new int[65535];
            for (int i = 0; i < ary.Length; i++)
                ary[i] = i;
            int TIMES = 5000;
            long sum = 0;
            Stopwatch sw = new Stopwatch();
            StringBuilder sb = new StringBuilder();
            sb.AppendLine("ary.Length,count var,foreach");
 
            for (int run = 0; run < 100; run++)
            {
                sw.Reset();
                sw.Start();
                for (int t = 0; t < TIMES; t++)
                {
                    sum = 0;
                    //比對i < ary.length
                    for (int i = 0; i < ary.Length; i++)
                    {
                        sum += ary[i];
                    }
                }
                sw.Stop();
                Console.WriteLine("{1} ary.Length = {0:N0}ms", 
                                    sw.ElapsedMilliseconds, sum);
                sb.Append(sw.ElapsedMilliseconds + ",");
                
                sw.Reset();
                sw.Start();
                for (int t = 0; t < TIMES; t++)
                {
                    int count = ary.Length;
                    sum = 0;
                    //將ary.Length存入count變數比對
                    for (int i = 0; i < count; i++)
                    {
                        sum += ary[i];
                    }
                }
                sw.Stop();
                Console.WriteLine("{1} count variable = {0:N0}ms", 
                                    sw.ElapsedMilliseconds, sum);
                sb.Append(sw.ElapsedMilliseconds + ",");
 
                sw.Reset();
                sw.Start();
                for (int t = 0; t < TIMES; t++)
                {
                    sum = 0;
                    //使用foreach
                    foreach (int n in ary)
                    {
                        sum += n;
                    }
                }
                sw.Stop();
                Console.WriteLine("{1} foreach = {0:N0}ms",
                                    sw.ElapsedMilliseconds, sum);
                sb.AppendLine(sw.ElapsedMilliseconds.ToString());
            }
            File.WriteAllText("d:\\result.csv", sb.ToString());
            Console.Read();
        }
    }
}

由執行結果來看,三種做法各有勝負,並未出現一面倒:

2147385345 ary.Length = 1,274ms
2147385345 count variable = 1,260ms
2147385345 foreach = 1,701ms //foreach > Length > 變數
2147385345 ary.Length = 1,805ms
2147385345 count variable = 1,472ms
2147385345 foreach = 2,151ms //foreach > Length > 變數
2147385345 ary.Length = 1,266ms
2147385345 count variable = 1,238ms
2147385345 foreach = 1,621ms //foreach > Length > 變數
2147385345 ary.Length = 1,623ms
2147385345 count variable = 1,658ms
2147385345 foreach = 1,298ms //變數 > Length > foreach
2147385345 ary.Length = 1,214ms
2147385345 count variable = 1,271ms
2147385345 foreach = 1,310ms //foreach > 變數 > Length
2147385345 ary.Length = 1,358ms
2147385345 count variable = 1,125ms
2147385345 foreach = 1,404ms //foreach > Length > 變數
2147385345 ary.Length = 1,421ms
2147385345 count variable = 1,471ms
2147385345 foreach = 1,432ms //變數 > foreach > Length
2147385345 ary.Length = 1,801ms
2147385345 count variable = 1,475ms
2147385345 foreach = 1,848ms //foreach > Length > 變數
2147385345 ary.Length = 1,608ms
2147385345 count variable = 1,527ms
2147385345 foreach = 1,587ms //Length > foreach > 變數
2147385345 ary.Length = 1,554ms
2147385345 count variable = 1,392ms
2147385345 foreach = 2,057ms //foreach > Length > 變數
...略...

然而,約略感覺將array.Length存成變數的做法領先次數較多,100次測試時間取平均值也印證了這點,for+count變數最快,其次是for+ary.Length,foreach最慢! (下圖紅框為100次測試的耗時平均值)

【結論】

雖然由平均值來看,將陣列長度存成變數的時間最短,但是30億次只差0.14秒,且執行期間很可能因其他因素逆轉結果(由反覆測試時三種方法各有勝負得知,甚至確知較複雜的foreach寫法也可能最快)。
故用.NET程式寫陣列迴圈時,不必庸人自擾去求這"奈米級"的差別,用最直覺、易讀的方式撰寫更重要。我會選擇直接用Array.Length,甚至用foreach也無妨,程式碼易理解就好。

歡迎推文分享:
Published 21 February 2013 09:44 PM 由 Jeffrey
Filed under: ,
Views: 7,898



意見

# Puritys said on 23 February, 2013 01:33 AM

使用變數還是比較好一點,畢竟不同的程式語言 & Compiler 會有不同的編譯方式。

# Nye said on 01 March, 2013 12:06 AM

[舉手] "宣告一個由65535個int組成的陣列,分別存入0到65535" 這樣不是有 63336 個才對?

# Nye said on 01 March, 2013 12:16 AM

我自己也打錯... 65536

# Jeffrey said on 01 March, 2013 04:56 AM

to Nye, 哈! 謝謝指正。文章說明處改為"存入0到65534"以便與程式碼相符。

你的看法呢?

(必要的) 
(必要的) 
(選擇性的)
(必要的) 
(提醒: 因快取機制,您的留言幾分鐘後才會顯示在網站,請耐心稍候)

5 + 3 =

搜尋

Go

<February 2013>
SunMonTueWedThuFriSat
272829303112
3456789
10111213141516
17181920212223
242526272812
3456789
 
RSS
創用 CC 授權條款
【廣告】
twMVC
最新回應

Tags 分類檢視
關於作者

一個醉心技術又酷愛分享的Coding魔人,十年的IT職場生涯,寫過系統、管過專案, 也帶過團隊,最後還是無怨無悔地選擇了技術鑽研這條路,近年來則以做一個"有為的中年人"自許。

文章典藏
其他功能

這個部落格


Syndication