Si BlockingQueue est plein, toute opération qui tente de stocker des choses sera bloquée et ne sera pas éveillée pour poursuivre ses opérations jusqu'à ce qu'il y ait un nouvel espace dans BlockingQueue.
Les principales méthodes fournies par BlockingQueue sont:
Ajouter (anobject): Ajouter un anobject à la BlockingQueue.
Offre (anobject): Ajoutez AnObject à BlockingQueue.
PUT (ANOBject): Ajoutez AnObject à BlockingQueue.
Poll (Time): Sortez l'objet classé d'abord dans BlockingQueue. Renvoie null lorsqu'il ne peut pas être récupéré.
Take (): Sortez l'objet classé d'abord dans BlockingQueue.
Il existe 4 implémentations spécifiques de BlockingQueue en fonction des différents besoins:
(1) ArrayBlockingQueue: Le constructeur de la taille spécifiée doit avoir un paramètre int pour indiquer sa taille. Les objets qu'il contient sont triés dans l'ordre FIFO (premier-in, premier out).
(2) LinkedBlockingQueue: BlockingQueue avec une taille variable.
Si le paramètre de taille n'est pas inclus, la taille du blocage généré est déterminée par Integer.max_value. Les objets qu'il contient sont triés dans l'ordre FIFO (premier-in, premier out).
Par rapport à LinkedBlockingQueue et ArrayBlockingQueue, les structures de données utilisées derrière elles sont différentes.
Le débit de données de LinkedBlockingQueue est supérieur à celui de ArrayBlockingQueue, mais sa prévisibilité des performances est inférieure à celle de ArrayBlockingQueue lorsque le nombre de threads est grand.
(3) PriorityBlockingQueue: similaire à LinkedBlockingQueue, mais le tri des objets qu'il contient n'est pas FIFO, mais est déterminé par l'ordre de tri naturel des objets ou l'ordre déterminé par le comparateur apporté par le constructeur.
(4) SynchronousQueue: Un blocage spécial, son fonctionnement doit être terminé alternativement en mettant et en récupérant.
La copie de code est la suivante:
Package com.yao;
Importer java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.blockingQueue;
Importer java.util.concurrent.executorService;
Importer java.util.concurrent.executors;
classe publique BlockingQueUeTest {
/ **
Définir le panier pour Apple
* /
panier de classe statique publique {
// panier, capable de contenir 3 pommes
BlockingQueue <string> Basket = new ArrayBlockingQueue <string> (3);
// produit des pommes et les mettre dans un panier
public void produce () lève l'interruption de l'exception {
// Mettez une pomme dans la méthode de put.
Basket.put ("An Apple");
}
// consomme des pommes et les retirer du panier
public String Consume () lance InterruptedException {
// Obtenez la méthode enlève une pomme.
String Apple = Basket.Take ();
retourner Apple;
}
public int getApplenumber () {
RETOUR BASKE.SIZE ();
}
}
// Méthode de test
public static void testbasket () {
// construire un panier avec des pommes
Basket final du panier = new Basket ();
// Définir le producteur de pomme
Classe Producteur implémente Runnable {
public void run () {
essayer {
while (true) {
// produit de la pomme
System.out.println ("Le producteur est prêt à produire des pommes:"
+ System.Currenttimemillis ());
Basket.Produce ();
System.out.println ("Producteur a fini de produire des pommes:"
+ System.Currenttimemillis ());
System.out.println ("Après la production, il y a des pommes:" + Basket.GetApplenumber () + ");
// sommeil de 300 ms
Thread.Sleep (300);
}
} catch (InterruptedException ex) {
}
}
}
// définir les consommateurs de pommes
Class Consumer implémente Runnable {
public void run () {
essayer {
while (true) {
// consommation de pomme
System.out.println ("Les consommateurs sont prêts à consommer Apple:"
+ System.Currenttimemillis ());
Basket.consume ();
System.out.println ("Le consommateur consomme Apple"
+ System.Currenttimemillis ());
System.out.println ("Après la consommation, il y a des pommes:" + Basket.getApplenumber () + ");
// 1000ms de sommeil
Thread.Sleep (1000);
}
} catch (InterruptedException ex) {
}
}
}
ExecutorService Service = exécutor.NewCachedThreadPool ();
Producteur producteur = nouveau producteur ();
Consommateur consommateur = nouveau consommateur ();
Service.Submit (producteur);
Service.Submit (consommateur);
// Une fois que le programme fonctionne pendant 10 secondes, toutes les tâches seront arrêtées
essayer {
Thread.Sleep (10000);
} catch (InterruptedException e) {
}
service.shutdownNow ();
}
public static void main (String [] args) {
BlockingQueueTest.TestBasket ();
}
}