C# 线程和队列

Question

这不是关于我可以或应该使用哪些不同的方法来以最佳方式利用队列，而是我所看到的对我来说毫无意义的事情。

void Runner() {
    // member variable
    queue = Queue.Synchronized(new Queue());
    while (true) {
        if (0 < queue.Count) {
            queue.Dequeue();
        }
    }
}

这是在单个线程中运行的：

var t = new Thread(Runner);
t.IsBackground = true;
t.Start();

其他事件在其他地方“排队”。我所看到的情况是在一段时间内，Dequeue 实际上会抛出 InvalidOperationException，队列为空。这应该是不可能的，因为计数如何保证那里有东西，而且我很肯定没有其他东西是“出队”的。

问题：

1. Enqueue 是否有可能在项目完全进入队列之前增加计数（无论这意味着什么......）？
2. 线程是否有可能在 Dequeue 语句处以某种方式重新启动（过期、重置...），但在它已经删除一个项目之后立即？

编辑（澄清）：

这些代码片段是实现后台帮助线程的 Wrapper 类的一部分。这里的Dequeue是唯一的Dequeue，所有的Enqueue/Dequeue都在Synchronized成员变量（queue）上。

Answer 1

另一个让线程安全使用队列的选项是 ConcurrentQueue<T> 类，它自 2009 年（这个问题的年份）开始引入。这可能有助于避免编写自己的同步代码，或者至少有助于使其更简单。

从 .NET Framework 4.6 开始，ConcurrentQueue<T> 还实现了接口 IReadOnlyCollection<T>。

Answer 2

“入队”数据的其他区域是否也使用相同的同步队列对象？为了使 Queue.Synchronized 是线程安全的，所有 Enqueue 和 Dequeue 操作必须使用相同的同步队列对象。

来自MSDN：

为了保证线程的安全 队列，所有操作都必须完成 仅通过此包装器。

编辑： 如果您正在循环涉及大量计算的许多项目，或者您正在使用长期线程循环（通信等），您应该考虑使用等待函数，例如System.Threading.Thread.Sleep、System.Threading.WaitHandle.WaitOne、System.Threading.WaitHandle.WaitAll、或 System.Threading.WaitHandle.WaitAny 在循环中，否则可能会影响系统性能。

Answer 3

问题 1：如果您使用的是同步队列，那么：不，您是安全的！但是您需要在供应商和馈线双方使用同步实例。

问题 2：在没有工作可做时终止工作线程是一项简单的工作。但是，无论哪种方式，您都需要一个监控线程，或者让队列在队列有事情要做时启动一个后台工作线程。最后一个听起来更像是 ActiveObject 模式，而不是一个简单的队列（Single-Responsibily-Pattern 说它应该只做队列）。

此外，我会选择阻塞队列而不是上面的代码。即使没有工作要做，您的代码的工作方式也需要 CPU 处理能力。阻塞队列让您的工作线程在无事可做时休眠。您可以在不使用 CPU 处理能力的情况下运行多个休眠线程。

C# 没有提供阻塞队列实现，但有很多实现。请参阅此example 和此one。

Answer 4

使用 Reflector，您可以看到不，直到添加项目后计数才会增加。

正如 Ben 指出的那样，您似乎确实有多个人调用 dequeue。

你说你肯定没有其他东西在调用 dequeue。那是因为你只有一个线程调用出队吗？ dequeue 是否在其他任何地方调用？

编辑：

我写了一些示例代码，但无法重现问题。它只是不停地运行，没有任何异常。

在出现错误之前它运行了多长时间？也许你可以分享更多的代码。

class Program
{
    static Queue q = Queue.Synchronized(new Queue());
    static bool running = true;

    static void Main()
    {
        Thread producer1 = new Thread(() =>
            {
                while (running)
                {
                    q.Enqueue(Guid.NewGuid());
                    Thread.Sleep(100);
                }
            });

        Thread producer2 = new Thread(() =>
        {
            while (running)
            {
                q.Enqueue(Guid.NewGuid());
                Thread.Sleep(25);
            }
        });

        Thread consumer = new Thread(() =>
            {
                while (running)
                {
                    if (q.Count > 0)
                    {
                        Guid g = (Guid)q.Dequeue();
                        Console.Write(g.ToString() + " ");
                    }
                    else
                    {
                        Console.Write(" . ");
                    }
                    Thread.Sleep(1);
                }
            });
        consumer.IsBackground = true;

        consumer.Start();
        producer1.Start();
        producer2.Start();

        Console.ReadLine();

        running = false;
    }
}

Answer 5

以下是the MSDN page 关于此主题的可能答案：

通过集合枚举是 本质上不是线程安全的 程序。即使是一个集合 同步，其他线程仍然可以 修改集合，这会导致 枚举器抛出异常。 为了保证线程安全 枚举，您可以锁定 在整个收集 枚举或捕获异常 由其他人所做的更改导致 线程。

我的猜测是你是对的 - 在某些时候，会发生竞争情况，你最终会出列一些不存在的东西。

Mutex 或 Monitor.Lock 在这里可能是合适的。

祝你好运！

Answer 6

我认为有问题的顺序是：

1. (0 < queue.Count) 计算结果为真，队列不为空。
2. 此线程获取preempted 并运行另一个线程。
3. 另一个线程从队列中删除一个项目，将其清空。
4. 此线程继续执行，但现在位于 if 块内，并尝试将空列表出列。

但是，你说没有其他东西正在出队......

尝试在 if 块中输出计数。如果您看到计数向下跳数，则表明其他人正在出队。