关于`for`和`foreach`，兼顾效率与安全open in new window

对于数组的访问，是应该使用for的方式的，因为这样性能更高。以下代码是恰当的。

Object[] objArray = ...;
int objArrayLength = objArray.Length;
for (int i = 0; i < objArrayLength; ++i)
{
    // do something ...
}

String str = ...;
int strLength = str.Length;
for (int i = 0; i < strLength; ++i) 
{
   // do something ...
}

对ArrayList这样的可使用下标进行随机访问的数据结构，使用下标访问，要比foreach的方式进行顺序访问，速度要快一些。foreach这样写法，使用的过程产生一个额外的对象Enumerator，而且每次访问需要更多的操作，降低性能。下面的两种写法编译出的代码是一样的：

第一种写法：

IList list = new ArrayList();
IEnumerator iter = list.GetEnumerator();
try
{
    while (iter.MoveNext())
    {
        Object obj = iter.Current;
        //do something ...
    }
}
finally
{
    IDisposable disposableObj = iter as IDisposable;
    if (disposableObj != null)
    {
        disposableObj.Dispose();
    }
}

第二种写法：

IList list = new ArrayList();
foreach (Object obj in list)
{
    //do something ...
}

对比这两种写法，第一种写法非常罗嗦，所以C#引入了foreach的语法。通过观察第一种写法，foreach是通过GetEnumerator获得一个IEnumerator对象，通过IEnumerator对象执行MoveNext()方法和获取Current属性进行遍历的。

我们再通过Reflector工具，查看mscorlib.dll中System.Collection.ArrayList的实现：

//为了简单起见，我只列出ArrayList的Add、Clear、GetEnumerator的代码
public class ArrayList
{
    //这是一个版本标识，ArrayList对象，每做一个修改操作，_version都会加1
    private int _version;

    public virtual int Add(object value)
    {
        int num1;
        if (this._size == this._items.Length)
        {
            this.EnsureCapacity((this._size + 1));
        }
        this._items[this._size] = value;
        ++this._version; //注意此处
        this._size = ((num1 = this._size) + 1);
        return num1;
    }

    public virtual void Clear()
    {
        Array.Clear(this._items, 0, this._size);
        this._size = 0;
        ++this._version; //注意此处
    }

    //每次调用GetEnumerator方法，都会构造一个FastArrayListEnumerator
    //或者ArrayListEnumeratorSimple对象。
    public virtual IEnumerator GetEnumerator()
    {
        if (base.GetType() == typeof(ArrayList))
        {
            return new ArrayList.FastArrayListEnumerator(this);
        }
        return new ArrayList.ArrayListEnumeratorSimple(this);
    }
}

通过上述代码可以看到，ArrayList是通过_version成员变量作版本标识的，每次执行Add、Clear等修改ArrayList内容的操作，都会将版本号加1，而每次调用GetEnumerator方法，都会构造一个FastArrayListEnumerator或者ArrayListEnumeratorSimple对象。我们再看FastArrayListEnumerator的实现：

class FastArrayListEnumerator
{
    private int version;

    internal FastArrayListEnumerator(ArrayList list)
    {
        this.list = list;
        this.index = -1;

        //获取构建FastArrayListEnumerator对象时ArrayList的版本号
        this.version = list._version; 

        this.lastIndex = (list._size - 1);
    }

    public bool MoveNext()
    {
        int num1;

        //比较ArrayList当前的版本号，
        //是否和构建FastArrayListEnumerator对象时的版本号一致
        //如果不一致，则抛出异常。
        if (this.version != this.list._version)
        {
            throw new InvalidOperationException(
                Environment.GetResourceString("InvalidOperation_EnumFailedVersion")
                );
        }

        //... ... 
    }
}

FastArrayListEnumerator对象构建时，当时时ArrayList的版本号。当执行MoveNext()操作时，检查ArrayList当前的版本号是否和FastArrayListEnumerator对象构建时的版本号一致，如果不一致就会抛出异常。

由于Enumerator中，做了版本检查处理的工作，所以使用foreach是线程安全，而使用for则不时。为什么呢？如果在使用foreach遍历对象的过程中，其他线程修改了List的内容，例如添加或者删除，就会出现不可知的错误，而使用foreach则能够正确抛出错误信息。

综上所述，结论如下：

使用for，更高效率。
使用foreach，更安全。

那么如何选择呢？我的建议是，在一些全局的，多线程可以访问的数据结构对象，使用foreach。而对本地变量，则使用for，效率和安全兼顾！例如：

public void F1(IList globalList)
{
    IList waitForDeleteList = new ArrayList();

    //全局变量，使用foreach，保证线程
    foreach (Object item in globalList)
    {
        if (condition)
        {
            waitForDeleteList.Add(item);
        }
    }

    //本地变量使用for，保证效率
    int waitForDeleteListCount = waitForDeleteList.Count;
    for (int i = 0; i < waitForDeleteListCount; ++i)
    {
        globalList.Remove(waitForDeleteList[i]);
    }
}

以上建议，对于在Java环境下也使用，我阅读过JDK 1.4的java.util.ArrayList的实现，.NET Framework的实现和JDK的实现，几乎是一样的，是否抄袭，见仁见智。上述的C#代码在Java环境中应为：

public void f1(List globalList) {
    List waitForDeleteList = new ArrayList();
    //全局变量，使用Iterator遍历，保证线程
    Iterator iter = globalList.iterator();
    while (iter.hasNext()) {
        Object item = iter.next();
        if (condition) {
            waitForDeleteList.add(item);
        }
    }
    
    //本地变量使用for，保证效率
    int waitForDeleteListCount = waitForDeleteList.size();
    for (int i = 0; i < waitForDeleteListCount; ++i) {
        globalList.remove(waitForDeleteList.get(i));
    }
}

注意，以上代码并不是做该项工作的最优算法，如果需要更高的效率，修改如下：

C#版本

public void F1(IList globalList)
{
    bool condition = true;
    IList waitForDeleteList = new ArrayList();

    //全局变量，使用foreach，保证线程
    int itemIndex = 0;
    foreach (Object item in globalList)
    {
        if (condition)
        {
            waitForDeleteList.Add(index);
        }
        ++itemIndex;
    }

    //本地变量使用for，保证效率
    int waitForDeleteListCount = waitForDeleteList.Count;
    for (int i = waitForDeleteListCount - 1; i >= 0; --i)
    {
        index = (int) waitForDeleteList[i];
        globalList.RemoveAt(itemIndex);
    }
}

Java版本：

public void f1(List globalList) {
    List waitForDeleteList = new ArrayList();
    //全局变量，使用Iterator遍历，保证线程
    Iterator iter = globalList.iterator();
    int index = 0;
    while (iter.hasNext()) {
        Object item = iter.next();
        if (condition) {
            waitForDeleteList.add(new Integer(index));
        }
        ++index;
    }
    
    //本地变量使用for，保证效率
    int waitForDeleteListCount = waitForDeleteList.size();
    for (int i = waitForDeleteListCount - 1; i >= 0; --i) {
       index = ((Integer) waitForDeleteList.get(i)).intValue();
        globalList.remove(index);
    }
}

1楼回复引用

...hoho,不错.. 分析的有道理.. 😃 2004-07-18 00:41 | hBifTs

2楼回复引用

呵呵，你说的意思我明白，不过有一些东西我还是觉得不能够完全认同你的。
1、线程安全。这里其实不涉及线程安全，所谓线程安全在foreach里面可以部分的保证，但是不能够完全保证。SyncRoot才是保证线程安全的东西，_version所保护的并不是线程安全，而是类似iterator模式里面的“安全遍历”问题。.NET Framework在这里有点“偷懒”并不能够保证“安全遍历”，如果在遍历期间修改了元素的内容，则会引发异常。既然是引发异常，那就不是“XX安全”或者“安全XX”，因为他认为这是一种异常情况，而不是“安全”情况。
你可以分析一下SyncRoot属性的行为，应该可以看到有一个什么特殊的类型，用于“线程安全”操作的。（这个是我估计的，因为在绝大多数的集合类型里面都会采用一个内部嵌套的类来提供线程安全问题。不过在.NET 2.0里面的Generic集合类型里面不提供这样的操作了，也就是不提供SyncRoot了，因为实际上还是有可能线程不安全的。）在这里面你会看到实际上是通过lock（或者类似的其它东西，目前我没有见到除了lock之外的其他东西，但不排除）来达到线程安全的，实际上并不会引发任何的exception。
试想一下，如果说一个操作能够引发异常，那么这个操作无论如何都不能够说是“安全”的操作。如果你的程序在foreach外面没有try...catch，甚至会让你的程序崩溃掉，试问，这样是安全的吗？不是吧？我宁愿认为for是“安全的”，尽管他不完全正确。
实际上如果你在for里面进行add/insert/remove操作，是完全可以判断应该怎么修改index的值，以达到安全遍历的效果。（例如对于add，index完全不需要修改；对于insert，如果insert_index < index 那么 index++ 否则不处理；remove和insert一样，除了把++换成--）
2、另外，我在你那篇文章里面回复的内容，实际上不会有安全问题，因为我把它copy出来了再进行操作。或者说，遍历的是keys和values数组，修改的是ht哈希表，对哈希表的修改不会影响keys和values，所以完全不会构成冲突。
不知道我说的是否有理呢？ 2004-07-18 10:50 | sumtec

3楼回复引用

分析得好。 2004-07-18 10:56 | 笨牛

4楼回复引用

@sumtec 你的回复中，对于安全的描述，你说的也有一定道理，既然引发了异常就不是安全了。其实我想表达的安全，就是你所说的安全遍历。一般编写多线程程序时，使用for都要很小心，因为for无法保证安全遍历，一旦出错，谁也不知道为什么，这种错误，可能极难被人发现。记得以前刚学多线程编程的时候，在一本Java关于多线程编程的书上，就介绍，多线程慎用for，常识呀。
你对Dictionay数据结构的遍历方式，我对此还是持保留态度。我认为，这种方式，数据量小，不一定快，大数据量肯定慢，如果中途有break退出，就更不值得了，因此不推荐使用。 2004-07-18 15:45 | 温少

5楼回复引用

学习！ 2004-07-19 08:25 | wngwz

6楼回复引用

如果在使用foreach遍历对象的过程中，其他线程修改了List的内容，例如添加或者删除，就会出现不可知的错误，而使用foreach则能够正确抛出错误信息。 2013-07-19 17:18 | 陈大欠

7楼回复引用

学习了,谢谢楼主. 我的感觉是,能用while就用while,能用for就用for. 毕竟多线程这个原因就有点飘了,况且C上面没有foreach 它处理并发问题照样利索. 还是自己变懒了,现在常年foreach了,鄙视自己 2013-11-11 09:28 | 喜欢兰花山丘

8楼回复引用

//本地变量使用for，保证效率
int waitForDeleteListCount = waitForDeleteList.size();
for (int i = waitForDeleteListCount - 1; i >= 0; --i) {
    index = ((Integer) waitForDeleteList.get(i)).intValue();
    globalList.remove(index);
}

最后这段代码，如何保证在进行这循环时globalList保持不变？如果globalList被改写，索引产生变化，不就不对了么。 2014-09-26 21:33 | Tekkaman

# 关于for和foreach，兼顾效率与安全open in new window

关于`for`和`foreach`，兼顾效率与安全open in new window