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

Question

I have a question, and I could do with some code examples to help me, and I feel it may help to give some background.

I have the need to create an engine of 3 Queues (in C#, winforms). The 3 Queues merely contain an "action" object. Actions get thrown into the engine, and stick themselves to the "most available" Queue (basically, the Queue with the lowest count). Almost all of the time the Queues can run discretely and asynchronously with no harm. However there is one "Action" situation which may happen, and when that type of "Action" occurs and does bubble to the front of a Queue, it must :

• wait for the other queues to stop their current actions
• lock/pause them when they are finished on their current Action
• run the Action alone until it finishes
• release the lock on the other 2 queues.

With the added issue that any of the 3 queues can lock the other 2.

Does anyone have any experience of this?

I hope so, it seems a bit painful :-) Thanks in advance

Answer 1

First off, I wouldn't suggest using three queues. I'd suggest using one queue and just have 3 different tasks reading from it. I'd also suggest using BlockingCollection<T> (which is just a wrapper for a ConcurrentQueue as it's easier to work with.

As for the rest, a ReaderWriterLockSlim ( Thanks Casperah ) should handle it easy enough. A Writer requires an exclusive lock, and a reader only locks out other writers, which is exactly your use case.

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 2

This is a combination of the single queue approach recommended by Servy and the 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 3

It seems that a System.Threading.ReaderWriterLock will do the job for you.

A normal task should do this:

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

And the advanced task should do this:

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

You can start as many ReaderLocks as you want, and they will keep running as expected. When a WriterLock is Acquired all the ReaderLocks has been released and only one WriterLock will run at a time.

Answer 4

My humble sugestion:

Create three objects

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

Each thread acquires lock over one object before running any action.

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

When THE action comes, the thread with THE action must acquire lock over the three objects, thus waiting for the other threads to finish their work, and preventing them from doing any more.

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

When THE action is finished, you release all three locks, and all is back to normal, with each thread holding it's own lock, and resuming actions.