在一个线程中添加到列表并在不锁定的情况下从另一个线程中删除列表有什么危险？

Question

前言

我知道 List 不是线程安全的，并且知道并发集合的存在，例如 ConcurrentBag、ConcurrentQueue 等，并且在某种程度上知道如何使用锁。我只想知道如果我这样做会有什么危险。

问题

比如说，如果我同时运行 2 个线程，一个向 List 添加值，另一个从同一个 List 中删除元素，会有什么危险？

我知道，如果我在两个线程中添加元素，危险可能很严重，因为 List 在内部调整集合的大小和重新索引，并且“种族”将破坏它，但 Add 和 Remove 本质上是相反的操作，我没有看到其中有任何“冲突”。

我也知道 Remove 也在内部调整集合的大小和重新索引，但老实说我不知道​​它们内部是如何工作的，我真的不知道“2 个相反的操作是否仍然会破坏数据”。如果是，以什么方式？ （除了“可能没有什么要删除的明显危险，因为元素还没有被添加”）。

Answer 1

很容易证明 List<T> 的这种使用会导致问题。

考虑以下程序 (also on DotNetFiddle)：

public class Program
{
    public static void Main()
    {
        List<int> list = new();
        Task.Run(() => addItems(list));
        Task.Run(() => removeItems(list));

        Console.WriteLine("Started. Press <return> to exit");
        Console.ReadLine();
    }

    static void addItems(List<int> list)
    {
        for (int i = 0; i < 100_000; ++i)
        {
            list.Add(i);
        }

        Volatile.Write(ref finished, true);

        Console.WriteLine("Finished writing items");
    }

    static void removeItems(List<int> list)
    {
        int n = 0;

        while (true)
        {
            if (list.Count > 0)
            {
                ++n;
                list.RemoveAt(0);
            }
            else
            {
                bool done = Volatile.Read(ref finished);

                if (done)
                    break;
            }
        }

        Console.WriteLine($"Finished reading {n} items");
    }

    static bool finished;
}

这将启动两个线程：一个将 100K 项写入列表，另一个从该列表中读取项目。

finished 字段就在那里表示 addItems() 任务已完成添加项目。

readItems() 任务计算它从列表中读取的项目数。显然，结果数应该等于添加到列表中的项目数。

然而，你会发现它有时读取的项目比写入的多，因为对列表的多线程访问导致了错误。 （您可能需要运行几次才能看到这个问题。）

这个故事的寓意是不要那样做！

---

作为旁注，如果您在列表访问周围添加一个锁，它将正常工作并打印正确数量的项目：

public class Program
{
    public static void Main()
    {
        List<int> list = new();
        Task.Run(() => addItems(list));
        Task.Run(() => removeItems(list));

        Console.WriteLine("Started. Press <return> to exit");
        Console.ReadLine();
    }

    static void addItems(List<int> list)
    {
        for (int i = 0; i < 100_000; ++i)
        {
            lock (locker)
            {
                list.Add(i);
            }
        }

        Volatile.Write(ref finished, true);

        Console.WriteLine("Finished writing items");
    }

    static void removeItems(List<int> list)
    {
        int n = 0;

        while (true)
        {
            lock (locker)
            {
                if (list.Count > 0)
                {
                    ++n;
                    list.RemoveAt(0);
                }
                else
                {
                    bool done = Volatile.Read(ref finished);

                    if (done)
                        break;
                }
            }
        }

        Console.WriteLine($"Finished reading {n} items");
    }

    static object locker = new();

    static bool finished;
}

Answer 2

如果我同时运行 2 个线程，一个向列表添加值，另一个从同一个列表中删除元素，会有什么危险？

最可能的错误是增加的值丢失，或者删除的值实际上没有被删除。也可能有例外，因为列表可能会进入无效状态。

虽然添加和删除可以被认为是相反的操作，但它们不是原子，这意味着它们会做很多事情，如果在操作过程中发生某些变化，它们将无法正常工作。与 Interlocked.Increment 和 Interlocked.Decrement 对比是原子的，因此可以安全地从多个线程使用。

最后，您唯一应该关心的是它是否被记录为线程安全的。如果它是线程安全的，你就可以使用它。如果不是，则只要从多个线程使用它，就需要使用锁。程序的正确行为比诸如锁的性能影响之类的小事情重要得多。如果不需要正确的行为，您只需将整个程序替换为 return 0; 即可获得近乎无限的加速

有一个可能的例外，并发读取内存是安全的，因此如果您确定该方法不会以任何方式改变对象，则可以在没有任何锁定的情况下并发使用它。 List<T> explicitly documents that 并发读取是安全的。