Tengo un hilo, que crea un número variable de hilos de trabajo y distribuye tareas entre ellos. Esto se resuelve pasando los hilos aTaskQueue objeto, cuya implementación verá a continuación.

Estos hilos de trabajo simplemente iteran sobre elTaskQueue objeto que se les dio, ejecutando cada tarea.

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();
    }
}

Como puede ver, estoy usando unAutoResetEvent objetar para asegurarse de que los hilos de trabajo no salgan prematuramente, es decir, antes de realizar cualquier tarea.

En una palabra:

el hilo principal asigna una tarea a un hilo porEnqeueue-ing una tarea a su TaskQueueel hilo principal notifica al hilo que ya no hay más tareas para ejecutar llamando a TaskQueueTerminar() métodoel subproceso de trabajo recupera la siguiente tarea asignada al llamar a TaskQueueDequeue() método

El problema es que elDequeue() método a menudolanza una InvalidOperationException, diciendo que la cola está vacía. Como puede ver, agregué algunos registros, y resulta que elAutoResetEvent no bloquea elDequeue (), a pesar de que no hubo llamadas a suConjunto() método.

Según tengo entendido, llamar a AutoResetEvent.Set () permitirá que continúe un subproceso en espera (que anteriormente llamó AutoResetEvent.WaitOne ()), y luego llama automáticamente a AutoResetEvent.Reset (), bloqueando al siguiente camarero.

Entonces, ¿qué puede estar mal? ¿Me equivoqué? ¿Tengo un error en alguna parte? Estoy sentado por encima de esto durante 3 horas, pero no puedo entender qué está mal. ¡Por favor, ayúdame!

¡Muchas gracias!