三个 c# 并发队列 - 在需要发生特定操作时如何暂停它们？

Question

我有一个问题，我可以用一些代码示例来帮助我，我觉得提供一些背景知识可能会有所帮助。

我需要创建一个包含 3 个队列的引擎（在 C# 中，winforms）。 3 个队列仅包含一个“动作”对象。动作被扔进引擎，并坚持到“最可用”的队列（基本上是计数最少的队列）。队列几乎在所有时间都可以离散和异步运行而不会造成任何伤害。但是，可能会发生一种“动作”情况，当这种类型的“动作”发生并且确实冒泡到队列的前面时，它必须：

• 等待其他队列停止当前操作
• 当他们完成当前操作时锁定/暂停他们
• 单独运行操作直到完成
• 释放对其他 2 个队列的锁定。

另外一个问题是 3 个队列中的任何一个都可以锁定其他 2 个。

有人有这方面的经验吗？

希望如此，这似乎有点痛苦 :-) 在此先感谢

Answer 1

这是single queue approach recommended by Servy 和ReaderWriterLock suggestion by Casperah 的组合。

ReaderWriterLockSlim throttler = new ReaderWriterLockSlim();
for (int i = 0; i < numWorkers; i++)
{
    Task.Factory.StartNew(() =>
    {
        foreach (Action nextAction in queue.GetConsumingEnumerable())
        {
            if (mustBeExectutedSerially(nextAction))
            {
                try
                {
                    throttler.EnterWriteLock();
                    nextAction();
                }
                finally
                {
                    throttler.ExitWriteLock();
                }
            }
            else
            {
                try
                {
                    throttler.EnterReadLock();
                    nextAction();
                }
                finally
                {
                    throttler.ExitReadLock();
                }
            }
        }
    });
}

Answer 2

首先，我不建议使用三个队列。我建议使用一个队列，只读取 3 个不同的任务。我还建议使用BlockingCollection<T>（它只是ConcurrentQueue 的包装，因为它更易于使用。

至于其余的，ReaderWriterLockSlim (Thanks Casperah) 应该很容易处理它。 Writer 需要独占锁，而 Reader 只锁定其他 writer，这正是您的用例。

var queue = new BlockingCollection<Action>();

int numWorkers = 3;
ReaderWriterLockSlim throttler = new ReaderWriterLockSlim();


for (int i = 0; i < numWorkers; i++)
{
    Task.Factory.StartNew(() =>
    {
        foreach (Action nextAction in queue.GetConsumingEnumerable())
        {
            if (mustBeExectutedSerially(nextAction))
            {
                try
                {
                    throttler.EnterWriteLock();
                    nextAction();
                }
                finally
                {
                    throttler.ExitWriteLock();
                }
            }
            else
            {
                try
                {
                    throttler.EnterReadLock();
                    nextAction();
                }
                finally
                {
                    throttler.ExitReadLock();
                }
            }
        }
    });
}

Answer 3

似乎 System.Threading.ReaderWriterLock 可以为您完成这项工作。

正常的任务应该这样做：

readerWriterLock.AcquireReaderLock(timeout);
try
{
    RunNormalAction();
}
finally
{
     readerWriterLock.ReleaseReaderLock();
}

高级任务应该这样做：

readerWriterLock.AcquireWriterLock(timeout);
try
{
    RunSpecialAction();
}
finally
{
     readerWriterLock.ReleaseWriterLock();
}

您可以根据需要启动任意数量的 ReaderLock，它们将按预期继续运行。 当一个 WriterLock 被获取时，所有的 ReaderLocks 都被释放，并且一次只运行一个 WriterLock。

Answer 4

我的谦虚建议：

创建三个对象

object threadlock1 = new object();
object threadlock2 = new object();
object threadlock3 = new object();

每个线程在执行任何操作之前都会获取一个对象的锁定。

lock (threadlock1)  // On thread 1, for example
{ //Run Action }

当 THE 动作到来时，带有 THE 动作的线程必须获得对这三个对象的锁定，从而等待其他线程完成它们的工作，并阻止它们再做任何事情。

lock (threadlock1)  // On thread 1, for example
{
 lock (threadlock2)
 {
  lock (threadlock3)
  {
    //Run THE Action 
  }
 }
}

当 THE 操作完成后，您释放所有三个锁，一切都恢复正常，每个线程都持有自己的锁，并恢复操作。