这个算法线程安全吗？

Question

我想知道下面的类是否线程安全并且在多线程上下文中完美运行？

public class ThreadSafeClass
{
    private List<int> commandList = new List<int>();
    public void AddCommand(int newCommand)
    {
        lock(syncObj) {
          commandList.Add(newCommand);
        }
    }
    public List<int> Split()
    {
        List<int> oldList = commandList;
        commandList = new List<int>();
        return oldList;
    }
}

ThreadA周期性调用split方法，很多线程调用AddCommand，split方法中的commandList指向内存中的某个list，分配新list时所有内容都在oldList中

拆分的目的是我想获取所有排队的命令，并在下一次调用中返回其余的命令，...同时让应用程序向 commandList 添加新项目。

因为我专注于拆分方法，我忘记为添加操作添加锁，因为它不是线程安全的谢谢：（可以 poyrazoğlu）但问题仍然存在于拆分

Answer 1

代码不是线程安全的，因为 List.Add 不能保证是。 （只是第一件事 - 还有其他问题）。

您也没有锁定共享数据（对commandList 的任何访问）。

Answer 2

这里的问题归结为您期望的行为。以你的 split 方法为例：

public List<int> Split()
{
    List<int> oldList = commandList;
    commandList = new List<int>();
    return oldList;
}

在分配oldList 和重新分配commandList 之间有一段时间，AddCommand 方法可以将值添加到commandList，这将出现在oldList 中：

public List<int> Split()
{
    // Say commandList contains 1 and 2

    List<int> oldList = commandList;

    // Now, on another thread, this happens:
    //
    // AddCommand 3
    // AddCommand 4
    // AddCommand 5
    //
    // The list hasn't been reassigned yet, so at this point oldList and
    // commandList both have 1, 2, 3, 4, and 5.

    commandList = new List<int>();

    // Now, commandList is empty, and oldList contains 1, 2, 3, 4, and 5,
    // even though it only contained 1 and 2 when you first assigned it.

    return oldList;
}

此序列表明oldList 不是仅包含其分配时的值的快照，而是实际上可以在分配它的时间和重新分配commandList 的时间之间进行修改。

这段代码的真实情况是，您添加的每个命令都将位于oldList 或commandList 恰好一次。无论有多少线程调用AddCommand，您都不会遇到任何重复。这听起来像是你想要完成的，所以我认为你的代码是正确的。

这是因为.NET reference assignment is atomic。在分配commandList 期间，没有任何时间段调用AddCommand 会导致值被添加到多个列表中或根本不被添加。

如果我误解了您的问题，请告诉我。

Answer 3

拥有线程安全的类并不意味着你的程序是线程安全的。线程安全类只是意味着您可以从多个线程中使用它，它仍然可以。线程安全基本上意味着“在多线程环境中保持一致”。

List 类不是线程安全的，因此您的代码绝对不是线程安全的。但想法是，即使你使用线程安全的集合，也并不意味着你的代码是线程安全的。

Answer 4

没有。 想想一个线程调用AddCommand 而另一个线程调用Split 的情况。您的新命令可能会被清除。您需要使用锁定机制来同步它。

// Bad
List oldList = commandList;
commandList.Add(newCommand); // newCommand would get lost.
commandList = new List();
return oldList; 

Answer 5

我不认为这是线程安全的。你修改了共享数据，我看不到任何守卫。

Answer 6

没有。

如果一个线程开始“添加”操作，而另一个线程正在执行split，则存在并发问题（提示，虽然add 的代码只有一行，但它是计算机本身的许多操作）

Answer 7

不，代码不是线程安全的。默认情况下，类不是线程安全的。

这是一个链接Why is List<T> not thread-safe?

Answer 8

List<T> 类不是线程安全的。使用 SynchronizedCollection<T>，其中 Add、Remove 等方法是线程安全的（枚举仍然不是，所以不要使用 foreach）

Answer 9

您应该通过锁定一个对象来同步对列表的访问（在这种情况下，它应该是所有方法的同一个对象），其中使用 commandList 本身是安全的，因为它不会重新创建或任何东西。

    public class ThreadSafeClass
    {
        private object sync = new object();
        private List<int> commandList = new List<int>();
        public void AddCommand(int newCommand)
        {
          lock(sync){
            commandList.Add(newCommand);
          }
        }
        public List<int> Split()
        {
          lock(sync){
            List<int> oldList = commandList;
            commandList = new List<int>();
          }
            return oldList;
        }
    }

Answer 10

您的班级在这里的形式似乎揭示了解决经典生产者-消费者问题变体的愿望：

http://en.wikipedia.org/wiki/Producer-consumer_problem

我可能误解了你的愿望。首先，正如许多其他人所提到的，您的代码中没有锁定机制，因此，这两种方法之间存在固有的竞态条件。如果您没有立即理解“竞争条件”一词的含义，那么您不应该编写多线程代码，请阅读书籍。不想在这里粗鲁，但我分享Alex's sentiments。

问题真的变成了：你想在这个类的多线程场景中做什么？这个问题的答案将引导您找到适合您应用程序的同步机制。

对于以下两个示例，让我们假设一个简单的互斥锁，就像其他人已经发布的那样。

1. 如果有 100 个线程都试图同时调用 AddCommand(...) 方法怎么办？其中 99 个会阻塞，尤其是在底层列表很大并且正在重新分配的情况下。可以吗？那是你要的吗？这在您正在开发的应用程序中是不可能的吗？

2. 在 100 个线程的情况下，其中只有一个线程会调用 Split()，而另外 99 个线程会调用 AddCommand(...)，调用 Split() 的线程将获得 99 个命令列表的子集，而不是全部，因为一个简单的锁定结构不会调用 Split() 阻塞，直到 all 挂起的 AddCommand(...) 调用完成，这将（从数据处理的角度来看）更理想。

现在，更复杂的锁定机制可能会解决这些问题；但是，这些问题可能在您的应用程序中不存在，因此不需要解决，一个简单的锁定机制就足够了。

希望这可以帮助您找到正确的方向。