Thread-safe File d'attente FIFO/Tampon

J'ai besoin de mettre en œuvre une sorte de tâche de la mémoire tampon. Exigences de base sont:

• Les tâches de processus dans un seul thread d'arrière-plan
• Recevoir des tâches à partir de plusieurs threads
• Processus ont TOUS reçu des tâches à savoir assurez-vous que le tampon est vidé de tampon des tâches après un signal d'arrêt est reçu
• Ordre des tâches reçues par thread doit être maintenue

Je pensais de la mise en œuvre à l'aide d'une File d'attente comme ci-dessous. Aimeraient des commentaires sur la mise en œuvre. Existe-il d'autres des idées brillantes pour mettre en œuvre une telle chose?

public class TestBuffer
{
private readonly object queueLock = new object();
private Queue<Task> queue = new Queue<Task>();
private bool running = false;
public TestBuffer()
{
}
public void start()
{
Thread t = new Thread(new ThreadStart(run));
t.Start();
}
private void run()
{
running = true;
bool run = true;
while(run)
{
Task task = null;
//Lock queue before doing anything
lock (queueLock)
{
//If the queue is currently empty and it is still running
//we need to wait until we're told something changed
if (queue.Count == 0 && running)
{
Monitor.Wait(queueLock);
}
//Check there is something in the queue
//Note - there might not be anything in the queue if we were waiting for something to change and the queue was stopped
if (queue.Count > 0)
{
task = queue.Dequeue();
}
}
//If something was dequeued, handle it
if (task != null)
{
handle(task);
}
//Lock the queue again and check whether we need to run again
//Note - Make sure we drain the queue even if we are told to stop before it is emtpy
lock (queueLock)
{
run = queue.Count > 0 || running;
}
}
}
public void enqueue(Task toEnqueue)
{
lock (queueLock)
{
queue.Enqueue(toEnqueue);
Monitor.PulseAll(queueLock);
}
}
public void stop()
{
lock (queueLock)
{
running = false;
Monitor.PulseAll(queueLock);
}
}
public void handle(Task dequeued)
{
dequeued.execute();
}
}

OriginalL'auteur user1300560 | 2012-09-11