不是线程安全的-公共静态列表<T>

Question

I was reading in MSDN that a List is thread safe when used as a public static type . However the following code snippet proves otherwise. I am trying to add and remove elements from the list but the remove method throws an error midway saying index out of bounds. What is going wrong here?

Is this a right implementation to check my theory. If not, can someone please suggest a better example.

class Program
{
    public static List<string> strlist = new List<string>();
    public static AutoResetEvent autoEvent = new AutoResetEvent(false);
    static void Main(string[] args)
    {

        strlist = new List<string>();
        new Thread(() => 
        {

            for(int i=0;i<10000000;i++)
            {
         strlist.Add("item1");
            }
            //Thread.Sleep(5000);
            autoEvent.Set();
        }).Start(); ;

        new Thread(() => {

         strlist.ForEach(e => strlist.Remove(e));

        }).Start();

        Console.WriteLine("Waiting");
        autoEvent.WaitOne();
        int ci = 0;

        strlist.ForEach(str => ci++);
        Console.WriteLine(ci.ToString() + " Done");
        Console.Read();


    }

}

Answer 1

I was reading in MSDN that a List is thread safe when used as a public static type.

That statement is not true. You probably are referring to this text:

Public static members of this type are thread safe.

That refers to members of the class List<T> . It does not refer to instances of the class List<T> .

Answer 2

Your reading was incorrect. You are using instance members ( .Add() etc); instance members are not thread-safe; MSDN is explicit about this.

Thread Safety

Public static (Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.

A List<T> can support multiple readers concurrently, as long as the collection is not modified. Enumerating through a collection is intrinsically not a thread-safe procedure. In the rare case where an enumeration contends with one or more write accesses, the only way to ensure thread safety is to lock the collection during the entire enumeration. To allow the collection to be accessed by multiple threads for reading and writing, you must implement your own synchronization.

In fact, List<T> doesn't have any static methods (the text merely asserts the default: static members are usually thread-safe; instance members are usually not thread-safe)

Answer 3

I think when they said "static" they didn't mean you have to use static keyword and everything works. They meant that as long as the list is static, as in "it never gets modified in any way," then you can use it from multiple threads without any problems.