这个算法线程安全吗？

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指向内存中的某个列表，当分配新列表时，其所有内容都在oldList中

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

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

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 方法可以将值添加到 < code>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 引用分配是原子的< /a>.在分配 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

不会。

如果一个线程开始“add”操作，而另一个线程正在执行 split 操作，那么就会出现并发问题（提示，尽管 add 的代码只有一行这是计算机本身的大量操作）

Answer 7

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

这是一个链接 为什么 List不是线程安全的？

Answer 8

List 类无论如何都不是线程安全的。使用 SynchronizedCollection 其中 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 的观点。

问题实际上变成了：您想在多线程场景中使用此类做什么？这个问题的答案将指导您为您的应用程序找到合适的同步机制。

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

1. 如果有 100 个线程同时尝试调用 AddCommand(...) 方法怎么办？其中 99 个将被阻塞，特别是在基础列表很大且处于重新分配过程中的情况下。可以吗？这就是你想要的吗？在您正在处理的应用程序中这是不可能的吗？

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

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

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