Comment implémenter une file d'attente de blocage en filetage dans .NET?

Construire une file d'attente de blocage en filetage dans .NET

Les applications multithread nécessitent souvent une file d'attente partagée où plusieurs threads ajoutent et récupéraient simultanément les éléments. Une file d'attente de blocage est idéale pour cela, une pause en ajoutant des fils lorsque la file d'attente est pleine et une pause en supprimant les fils lorsque la file d'attente est vide.

Une solution de file d'attente de blocage robuste

L'amélioration de l'implémentation suivante traite des conditions de course potentielles en utilisant Monitor pour la synchronisation et offre un mécanisme de fermeture gracieux:

SizeQueue<T> implémentation

Cet exemple utilise un synchronisé Queue<T> et Monitor pour un blocage et un déblocage de threads efficaces:

<code class="language-csharp">class SizeQueue<T>
{
    private readonly Queue<T> queue = new Queue<T>();
    private readonly int maxSize;
    private bool closing = false; // Flag for graceful closure

    public SizeQueue(int maxSize) { this.maxSize = maxSize; }

    public void Enqueue(T item)
    {
        lock (queue)
        {
            while (queue.Count >= maxSize && !closing) // Check for closure
            {
                Monitor.Wait(queue);
            }
            if (!closing) // Add only if not closing
            {
                queue.Enqueue(item);
                Monitor.PulseAll(queue); // Signal potential dequeue operations
            }
        }
    }

    public T Dequeue()
    {
        lock (queue)
        {
            while (queue.Count == 0 && !closing) // Check for closure
            {
                Monitor.Wait(queue);
            }
            if (!closing) // Dequeue only if not closing
            {
                T item = queue.Dequeue();
                Monitor.PulseAll(queue); // Signal potential enqueue operations
                return item;
            }
            else
            {
                throw new InvalidOperationException("Queue is closed.");
            }
        }
    }

    public bool TryDequeue(out T value)
    {
        lock (queue)
        {
            while (queue.Count == 0)
            {
                if (closing)
                {
                    value = default(T);
                    return false;
                }
                Monitor.Wait(queue);
            }
            value = queue.Dequeue();
            Monitor.PulseAll(queue);
            return true;
        }
    }


    public void Close()
    {
        lock (queue)
        {
            closing = true;
            Monitor.PulseAll(queue); // Wake up any waiting threads
        }
    }
}</code>

Cet SizeQueue<T> amélioré fournit une file d'attente de blocage et de blocage avec une méthode Close() pour l'arrêt contrôlé, la prévention des impasses et la fin de la terminaison gracieuse de la consommation de threads. La méthode TryDequeue permet de vérifier l'état de la file d'attente avant de tenter de désactiver.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!