Comment implémenter une file d'attente de blocage en Java

L'utilisation de l'interface BlockingQueue intégrée dans Java est le moyen recommandé d'implémenter les files d'attente de blocage. Par exemple, ArrayBlockingQueue fournit une file d'attente en filetage bornée basée sur des tableaux; 2. Vous pouvez créer une file d'attente de blocage personnalisée de zéro à Synchronisé, attendre () et notifyall () pour vous assurer que la méthode de put bloque lorsque la file d'attente est pleine, la méthode Take bloque lorsque la file d'attente est vide et utilise une boucle while pour empêcher le faux réveil; 3. L'implémentation intégrée est une file d'attente, d'excellentes performances et prend en charge les opérations de délai d'attente. Il doit être prioritaire à utiliser dans l'environnement de production, et les implémentations personnalisées sont principalement utilisées pour l'apprentissage ou les besoins spéciaux.

La mise en œuvre d'une file d'attente de blocage dans Java implique la création d'une file d'attente en filetage qui bloque lorsqu'il essaie de se déshabiller d'une file d'attente vide ou d'une file d'attente dans une file d'attente complète (si bornée). Vous pouvez en créer un à partir de zéro en utilisant une synchronisation de bas niveau ou tirer parti des utilitaires de concurrence existants. Voici comment faire les deux.

1. Utilisation d'interface BlockingQueue intégrée (recommandée)

Java fournit une interface java.util.concurrent.BlockingQueue avec plusieurs implémentations prêtes à l'emploi. C'est le moyen standard et le plus sûr.

Implémentations courantes:

• ArrayBlockingQueue - Fitre bornée basée sur un tableau.
• LinkedBlockingQueue - File d'attente limité en éventuellement en fonction des nœuds liés.
• PriorityBlockingQueue - file d'attente prioritaire illimitée.
• SynchronousQueue - Transfère les éléments directement entre les fils.

Exemple: Utilisation de ArrayBlockingQueue

 Importer java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.blockingQueue;

classe publique ProduCerConsumerexample {
    private static final int queue_capacity = 5;
    BlockingQueue statique privée <Integer> queue = new ArrayBlockingQueue <> (queue_capacity);

    public static void main (String [] args) {
        Thread producteur = nouveau thread (() -> {
            essayer {
                pour (int i = 0; i <10; i) {
                    queue.put (i); // blocs si la file d&#39;attente est pleine
                    System.out.println ("produit:" i);
                    Thread.Sleep (100);
                }
            } catch (InterruptedException e) {
                Thread.currentThread (). Interrupt ();
            }
        });

        Thread Consumer = nouveau thread (() -> {
            essayer {
                while (true) {
                    Integer Value = Queue.Take (); // bloque si la file d&#39;attente est vide
                    System.out.println ("Consommé:" Valeur);
                    if (valeur == 9) Break; // s&#39;arrête après avoir consommé tout
                    Thread.Sleep (200);
                }
            } catch (InterruptedException e) {
                Thread.currentThread (). Interrupt ();
            }
        });

        producteur.start ();
        Consumer.start ();
    }
}

Cette approche est en sécurité, efficace et les gèrent automatiquement.

2. Construire une file d'attente de blocage personnalisée à partir de zéro

Si vous souhaitez comprendre les internes ou avoir besoin d'un comportement personnalisé, vous pouvez implémenter un en utilisant synchronized , wait() et notifyAll() .

Points clés:

• Utilisez des méthodes ou des blocs synchronized pour l'exclusion mutuelle.
• Utilisez wait() pour bloquer les threads lorsque la file d'attente est vide (pour prendre) ou complète (pour put).
• Utilisez notifyAll() pour réveiller les fils d'attente lorsque l'état change.

Exemple: file d'attente de blocage délimitée sur mesure

 import java.util.linkedlist;
Importer Java.util.Queue;

classe publique CustomBlockingQueue <T> {
    file d&#39;attente finale privée <T> queue = new LinkedList <> ();
    Capacité INT finale privée;

    public CustomBlockingQueue (INT CAPACITY) {
        this.capacity = capacité;
    }

    Public synchronisé vide put (ttel) lance InterruptedException {
        while (queue.size () == capacité) {
            attendez(); // attendez si vous
        }
        queue.add (article);
        notifyall (); // informer les consommateurs d&#39;attente
    }

    Le public synchronisé t à prendre () lance InterruptedException {
        while (queue.isempty ()) {
            attendez(); // attendez si vide
        }
        T item = queue.poll ();
        notifyall (); // informer les producteurs d&#39;attente
        return item;
    }

    public synchronisé int size () {
        return queue.size ();
    }
}

Exemple d'utilisation

 classe publique CustomBlockingQueueDemo {
    public static void main (String [] args) {
        CustomBlockingQueue <Integer> queue = new CustomBlockingQueue <> (3);

        Thread producteur = nouveau thread (() -> {
            essayer {
                pour (int i = 0; i <5; i) {
                    queue.put (i);
                    System.out.println ("produit:" i);
                    Thread.Sleep (100);
                }
            } catch (InterruptedException e) {
                Thread.currentThread (). Interrupt ();
            }
        });

        Thread Consumer = nouveau thread (() -> {
            essayer {
                pour (int i = 0; i <5; i) {
                    Integer Value = Queue.Take ();
                    System.out.println ("Consommé:" Valeur);
                    Thread.Sleep (200);
                }
            } catch (InterruptedException e) {
                Thread.currentThread (). Interrupt ();
            }
        });

        producteur.start ();
        Consumer.start ();
    }
}

Notes de conception clés

• Utilisez while les boucles avec wait() : Vérifiez toujours les conditions dans une boucle pour éviter les réveils parasites.
• Appel notifyAll() au lieu de notify() : s'assure que tous les threads d'attente pertinents ont la possibilité de procéder.
• Sécurité du thread : Tout l'accès à l'état partagé doit être synchronisé.
• Boundé vs illimité : décidez si votre file d'attente doit avoir une capacité fixe.

L'utilisation des implémentations BlockingQueue de java.util.concurrent est préférée dans la production. Rouler le vôtre est utile pour l'apprentissage ou des cas d'utilisation très spécifiques. Les versions intégrées sont bien testées, performantes et les délais d'attente de soutien ( offer(e, timeout) , poll(timeout) ), qui sont plus difficiles à se répercuter manuellement.

Fondamentalement, à moins que vous n'ayez une raison spéciale, optez pour ArrayBlockingQueue ou LinkedBlockingQueue .

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!