Зависимые задачи очереди C# для обработки пулом потоков

лучший способ-использовать Task Parallel Library (TPL) и Continuations. Продолжение не только позволяет создать поток задач, но и обрабатывает исключения. Это большое введение в TPL. Но чтобы дать вам некоторое представление...

вы можете запустить задачу TPL с помощью

Task task = Task.Factory.StartNew(() => 
{
    // Do some work here...
});

теперь, чтобы начать вторую задачу, когда предыдущая задача заканчивается (по ошибке или успешно), вы можете использовать ContinueWith метод

Task task1 = Task.Factory.StartNew(() => Console.WriteLine("Antecedant Task"));
Task task2 = task1.ContinueWith(antTask => Console.WriteLine("Continuation..."));

Итак, как только task1 завершает, завершает работу или отменяется task2 'пожары и начинает работать. Обратите внимание, что if task1 было завершено до достижения второй строке кода task2 будет запланировано выполнить немедленно. The antTask аргумент, переданный второй лямбде, является ссылкой на предшествующую задачу. См.этой ссылке для более подробных примеров...

вы также можете передать результаты продолжения из предшествующей задачи

Task.Factory.StartNew<int>(() => 1)
    .ContinueWith(antTask => antTask.Result * 4)
    .ContinueWith(antTask => antTask.Result * 4)
    .ContinueWith(antTask =>Console.WriteLine(antTask.Result * 4)); // Prints 64.

Примечание. Обязательно читайте дальше обработка исключений в первой ссылке, так как это может привести новичка в ОСАГО в заблуждение.

последнее, что нужно посмотреть, в частности, для того, что вы хотите, это дочерние задачи. Дочерние задачи-это те, которые создаются как AttachedToParent. В этом случае продолжение не будет выполняться, пока не будут выполнены все дочерние задачи

TaskCreationOptions atp = TaskCreationOptions.AttachedToParent;
Task.Factory.StartNew(() =>
{
    Task.Factory.StartNew(() => { SomeMethod() }, atp);
    Task.Factory.StartNew(() => { SomeOtherMethod() }, atp); 
}).ContinueWith( cont => { Console.WriteLine("Finished!") });

надеюсь, это поможет.

Edit: вы посмотрели на ConcurrentCollections в частности BlockngCollection<T>. Так что в вашем случае вы может использовать что-то вроде

public class TaskQueue : IDisposable
{
    BlockingCollection<Action> taskX = new BlockingCollection<Action>();

    public TaskQueue(int taskCount)
    {
        // Create and start new Task for each consumer.
        for (int i = 0; i < taskCount; i++)
            Task.Factory.StartNew(Consumer);  
    }

    public void Dispose() { taskX.CompleteAdding(); }

    public void EnqueueTask (Action action) { taskX.Add(Action); }

    void Consumer()
    {
        // This seq. that we are enumerating will BLOCK when no elements
        // are avalible and will end when CompleteAdding is called.
        foreach (Action action in taskX.GetConsumingEnumerable())
            action(); // Perform your task.
    }
}

возможно решение .NET 4.0 на основе TPL, скрывая при этом тот факт, что ему нужно где-то хранить родительскую задачу. Например:

class QueuePool
{
    private readonly Task[] _queues;

    public QueuePool(int queueCount)
    { _queues = new Task[queueCount]; }

    public void Enqueue(int queueIndex, Action action)
    {
        lock (_queues)
        {
           var parent = _queue[queueIndex];
           if (parent == null)
               _queues[queueIndex] = Task.Factory.StartNew(action);
           else
               _queues[queueIndex] = parent.ContinueWith(_ => action());
        }
    }
}

это использование одной блокировки для всех очередей, чтобы проиллюстрировать идею. Однако в производственном коде я бы использовал блокировку для каждой очереди, чтобы уменьшить конкуренцию.

похоже, что дизайн, который у вас уже есть, хорош и работает. Ваши рабочие потоки (по одному на очередь) работают долго, поэтому, если вы хотите использовать вместо этого задачи, укажите TaskCreationOptions.LongRunning таким образом, вы получаете выделенный рабочий поток.

но на самом деле нет необходимости использовать ThreadPool здесь. Это не дает много преимуществ для длительной работы.