线程与 FIFO 顺序同步

Question

我找到了这个帮手class:

public sealed class QueuedLock
{
    private object innerLock;
    private volatile int ticketsCount = 0;
    private volatile int ticketToRide = 1;

    public QueuedLock()
    {
        innerLock = new Object();
    }

    public void Enter()
    {
        int myTicket = Interlocked.Increment(ref ticketsCount);
        Monitor.Enter(innerLock);
        while (true)
        {

            if (myTicket == ticketToRide)
            {
                return;
            }
            else
            {
                Monitor.Wait(innerLock);
            }
        }
    }

    public void Exit()
    {
        Interlocked.Increment(ref ticketToRide);
        Monitor.PulseAll(innerLock);
        Monitor.Exit(innerLock);
    }
}

此处：

Is there a synchronization class that guarantee FIFO order in C#?

它对我来说很好，但我刚刚阅读了一些关于使用这些可变变量的主题的评论，我不确定这里是否存在问题。我理解代码并在我的应用程序中实现它以完成正确的工作，但我承认我看不到这种方法在未来有负面影响，至少，如果有的话。

我还没有看到很多方法可以做到这一点，所以最好有一个完整且安全的版本可以在任何情况下使用。

所以基本上，问题是，可以改进这种方法吗？它有任何细微的问题吗？

Answer 1

对于多线程FIFO（队列），.NET已经提供了ConcurrentQueue，我建议使用ConcurrentQueue而不是低级锁。

MSDN：ConcurrentQueue

Answer 2

您也可以为此查看 TPL Dataflow BufferBlock class：

// Hand-off through a BufferBlock<T>
private static BufferBlock<int> m_buffer = new BufferBlock<int>();

// Producer
private static void Producer()
{
    while(true)
    {
        int item = Produce();
        // storing the messages in FIFO queue
        m_buffer.Post(item);
    }
}

// Consumer
private static async Task Consumer()
{
    while(true)
    {
        int item = await m_buffer.ReceiveAsync();
        Process(item);
    }
}

// Main
public static void Main()
{
    var p = Task.Factory.StartNew(Producer);
    var c = Consumer();
    Task.WaitAll(p,c);
}

线程与 FIFO 顺序同步

Threads synchronization with FIFO order

c#

multithreading

fifo