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

Эти рабочие потоки просто перебираютTaskQueue объект им был дан, выполняя каждую задачу.

private class TaskQueue : IEnumerable<Task>
{
    public int Count
    {
        get
        {
            lock(this.tasks)
            {
                return this.tasks.Count;
            }
        }
    }

    private readonly Queue<Task> tasks = new Queue<Task>();
    private readonly AutoResetEvent taskWaitHandle = new AutoResetEvent(false);

    private bool isFinishing = false;
    private bool isFinished = false;

    public void Enqueue(Task task)
    {
        Log.Trace("Entering Enqueue, lock...");
        lock(this.tasks)
        {
            Log.Trace("Adding task, current count = {0}...", Count);
            this.tasks.Enqueue(task);

            if (Count == 1)
            {
                Log.Trace("Count = 1, so setting the wait handle...");
                this.taskWaitHandle.Set();
            }
        }
        Log.Trace("Exiting enqueue...");
    }

    public Task Dequeue()
    {
        Log.Trace("Entering Dequeue...");
        if (Count == 0)
        {
            if (this.isFinishing)
            {
                Log.Trace("Finishing (before waiting) - isCompleted set, returning empty task.");
                this.isFinished = true;
                return new Task();
            }

            Log.Trace("Count = 0, lets wait for a task...");
            this.taskWaitHandle.WaitOne();
            Log.Trace("Wait handle let us through, Count = {0}, IsFinishing = {1}, Returned = {2}", Count, this.isFinishing);

            if(this.isFinishing)
            {
                Log.Trace("Finishing - isCompleted set, returning empty task.");
                this.isFinished = true;
                return new Task();
            }
        }

        Log.Trace("Entering task lock...");
        lock(this.tasks)
        {
            Log.Trace("Entered task lock, about to dequeue next item, Count = {0}", Count);
            return this.tasks.Dequeue();
        }
    }

    public void Finish()
    {
        Log.Trace("Setting TaskQueue state to isFinishing = true and setting wait handle...");
        this.isFinishing = true;

        if (Count == 0)
        {
            this.taskWaitHandle.Set();
        }
    }

    public IEnumerator<Task> GetEnumerator()
    {
        while(true)
        {
            Task t = Dequeue();
            if(this.isFinished)
            {
                yield break;
            }

            yield return t;
        }
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

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

В двух словах:

основной поток назначает задачу потокуEnqeueue-направление задачи в ее TaskQueueосновной поток уведомляет поток, что больше нет задач для выполнения, вызывая TaskQueueКонец() методрабочий поток извлекает следующую задачу, назначенную ему, вызывая TaskQueueDequeue() метод

Проблема в том, чтоDequeue() метод частовыдает InvalidOperationExceptionГоворят, что очередь пуста. Как вы можете видеть, я добавил некоторые записи, и оказалось, чтоAutoResetEvent не блокируетВедиеие ()хотя не было никаких звонков на егоЗадавать() метод.

Насколько я понимаю, вызов AutoResetEvent.Set () позволит продолжить ожидающий поток (который ранее вызывал AutoResetEvent.WaitOne ()), а затем автоматически вызывает AutoResetEvent.Reset (), блокируя следующего официанта.

Так что может быть не так? Я что-то не так понял? У меня где-нибудь есть ошибка? Я сижу над этим уже 3 часа, но не могу понять, что не так. Пожалуйста, помогите мне!

Большое спасибо!