ConcurrentQueue<T> 或 Queue<T> 当一个线程只入队而另一个线程只出队时

Question

我有一个 FIFO 和两个线程。一个线程只会从 FIFO 入队，而另一个线程只会从 FIFO 出队。我需要使用 ConcurrentQueue 还是 Queue 就足够了？

Answer 1

简短的回答：是的，您仍然需要一种线程安全的解决方案 - 即使只有一个写入器线程和一个读取器线程。

使用ConcurrentQueue会更容易。如果您愿意，可以使用队列来代替，但您必须自己进行锁定。

Answer 2

如果您有多个线程，则您的Queue对象实例将需要线程安全和同步。为了避免重新发明轮子并自己动手，我建议使用 Microsoft 的ConcurrentQueue.

MSDN：https : //docs.microsoft.com/en-us/dotnet/api/system.collections.queue? view = netframework- 4.7.1

如果需要同时从多个线程访问集合，请使用 ConcurrentQueue 或 ConcurrentStack。

如果您使用具有多个线程更新对象实例的Queue（即，不是ConcurrentQueue），您可能会遇到运行时异常，例如：

• 参数超出范围异常
• ArgumentException ( InvalidOffLen)
• ExceptionResource.InvalidOperation_EmptyQueue

如果 Queue 的内部状态正在被修改但由于 CPU 线程调度而尚未完成，则可能出现异常。如果另一个线程在处于不一致状态时访问 Queue 对象实例，您可能并且可能会遇到这些异常。

要审查的源代码：

.Net 框架 4.7.1 https://referencesource.microsoft.com/#System/compmod/system/collections/generic/queue.cs

示例控制台应用程序：

运行以下作为您的实验室，您应该会遇到 System.InvalidOperationException

System.InvalidOperationException: '在实例化枚举器后修改了集合。'

class Program
{
    static Queue<string> Queue = new Queue<string>();

    static void Main(string[] args)
    {
        Thread producer = new Thread(Enqueue);
        Thread consumer = new Thread(Dequeue);

        producer.Start();
        consumer.Start();

        Console.ReadKey();
    }

    static void Enqueue()
    {
        for (int i = 0; i < 10000; i++)
        {
            Queue.Enqueue("Number : " + i);
            SimulateWork();
        }
    }

    static void Dequeue()
    {
        while (true)
        {
            if (Queue.Any())
            {
                Console.WriteLine(Queue.Dequeue());
                SimulateWork();
            }
        }
    }

    static void SimulateWork()
    {
        for (int i = 0; i < 1000000; i++)
        { }
    }
}

本实验演示了Queue在不一致状态下访问实例时会发生什么。即使只有一个生产者和一个消费者，您也需要适当的同步。

如果您在EnqueueandDequeue操作周围添加锁定或同步，您会发现它运行没有问题。

            lock (lockObject)
            {
                Queue.Enqueue("Number : " + i);
                SimulateWork();
            }


            lock (lockObject)
            {
                if (Queue.Any())
                {
                    Console.WriteLine(Queue.Dequeue());
                    SimulateWork();
                }
            }

他这样说，我不建议你手动添加的锁，这将阻止。这更像是一个实验室练习，可帮助您了解原因。

Microsoft 投入了大量时间为我们提供线程安全集合，例如ConcurrentQueue使用细粒度锁定和无锁机制。

一些并发集合类型使用轻量级同步机制，例如 SpinLock、SpinWait、SemaphoreSlim 和 CountdownEvent，它们是 .NET Framework 4 中的新功能。这些同步类型通常在将线程置于真正的 Wait 之前使用短暂的忙旋转状态。当预计等待时间非常短时，旋转的计算成本远低于等待，后者涉及昂贵的内核转换。对于使用自旋的集合类，这种效率意味着多个线程可以以非常高的速度添加和删除项目。有关自旋与阻塞的更多信息，请参阅 SpinLock 和 SpinWait。

如上所述，如果您有多个线程，则您的Queue对象实例将需要线程安全和同步。为了避免重新发明轮子并自己动手，我强烈建议使用 Microsoft 的ConcurrentQueue.

参考：

线程安全集合：

https://docs.microsoft.com/en-us/dotnet/standard/collections/thread-safe/

锁定关键字

https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/lock-statement

穿线：

https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/threading/index