Question

我找到了这个助手类：

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 // 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); }课程：

{{1}}

线程与FIFO顺序

2 个答案: