Wenn Blockingqueue voll ist, wird jeder Betrieb, der versucht, Dinge zu speichern, blockiert und erst erweckt, um den Betrieb fortzusetzen, bis ein neuer Raum für Blockingqueue vorhanden ist.
Die Hauptmethoden, die Blockingqueue bereitstellen, sind:
Fügen Sie (AnObject): Anobjekt fügen Sie dem Blockingqueue hinzu.
Angebot (Anobject): Fügen Sie Anobject in das Blockingqueue hinzu.
Put (AnoBject): Fügen Sie Anobject in das Blockingqueue hinzu.
Umfrage (Zeit): Nehmen Sie das Objekt zuerst in Blockingqueue heraus. Gibt NULL zurück, wenn es nicht abgerufen werden kann.
Nehmen Sie (): Nehmen Sie das Objekt zuerst in Blockingqueue heraus.
Es gibt 4 spezifische Implementierungen von Blockingqueue entsprechend unterschiedlichen Anforderungen:
(1) ArrayBlockingQueue: Der Konstruktor der angegebenen Größe muss einen INT -Parameter haben, um seine Größe anzuzeigen. Die Objekte, die es enthält, sind in der FIFO-Reihenfolge (erste, erste) sortiert.
(2) Linked Blockingqueue: Blockierung mit unterschiedlicher Größe.
Wenn der Größenparameter nicht enthalten ist, wird die Größe des erzeugten Blockierungsqueue durch Integer.max_Value bestimmt. Die Objekte, die es enthält, sind in der FIFO-Reihenfolge (erste, erste) sortiert.
Im Vergleich zu LinkedBlockingQueueue und ArrayBlockingConeue sind die dahinter verwendeten Datenstrukturen unterschiedlich.
Der Datendurchsatz von LinkedBlockingQueue ist größer als der von ArrayBlockingQueue, aber seine Leistungsvorhersagbarkeit ist niedriger als die von ArrayBlockingQueue, wenn die Anzahl der Fäden groß ist.
(3) PriorityBlockingQueue: Ähnlich wie Linked BlockingQueue, aber die Sortierung von Objekten, die sie enthält, ist nicht FIFO, sondern wird durch die natürliche Sortierreihenfolge von Objekten oder die von dem vom Konstruktor eingeführte Vergleiche bestimmt.
(4) Synchronousqueue: Ein spezielles Blockingqueue muss der Betrieb abwechselnd durch das Einlegen und Abholen abgeschlossen werden.
Die Codekopie lautet wie folgt:
Paket com.yao;
Import Java.util.Concurrent
Import Java.util.Concurrent.BlockingQueue;
import Java.util.concurrent.executorService;
import Java.util.concurrent.executors;
öffentliche Klasse BlockingqueueTest {
/**
Definieren des Korbs für Apfel
*/
öffentlicher statischer Klassenkorb {
// Korb, in der Lage, 3 Äpfel zu halten
BlockingQueue <String> basket = new ArrayBlockingQueue <string> (3);
// Äpfel produzieren und in einen Korb legen
public void producs () wirft InterruptedException {aus {
// einen Apfel in die Put -Methode einfügen.
basket.put ("ein Apfel");
}
// Äpfel verbrauchen und sie aus dem Korb nehmen
public String conseum () löst InterruptedException {aus {
// METHODE einen Apfel herausholen.
String Apple = basket.take ();
Apfel zurückgeben;
}
public int getApplenumber () {
return basket.size ();
}
}
// Testmethode
public static void testbasket () {
// Erstellen Sie einen Korb mit Äpfeln
endgültiger Korb = neuer Basket ();
// Apple Producer definieren
Klassenproduzent implementiert Runnable {
public void run () {
versuchen {
while (wahr) {
// Apfel produzieren
System.out.println ("Produzent ist bereit, Äpfel zu produzieren:"
+ System.currentTimemillis ());
basket.produce ();
System.out.println ("Produzent hat die Erzeugung von Äpfeln fertiggestellt:"
+ System.currentTimemillis ());
System.out.println ("Nach der Produktion gibt es Äpfel:"+basket.getApplenumber ()+");
// 300 ms Schlaf
Thread.Sleep (300);
}
} catch (InterruptedException ex) {
}
}
}
// Apple -Verbraucher definieren
Klassenverbraucher implementiert runnable {
public void run () {
versuchen {
while (wahr) {
// Apfelverbrauch
System.out.println ("Verbraucher sind bereit, Apple zu konsumieren:"
+ System.currentTimemillis ());
basket.consume ();
System.out.println ("Verbraucher konsumiert Apple"
+ System.currentTimemillis ());
System.out.println ("Nach dem Verbrauch gibt es Äpfel:"+basket.getApplenumber ()+");
// 1000 ms Schlaf
Thread.sleep (1000);
}
} catch (InterruptedException ex) {
}
}
}
ExecutorService Service = Executors.NewCachedThreadpool ();
Produzent produzent = neuer Produzent ();
Consumer Consumer = New Consumer ();
Service.Submit (Produzent);
Service.Submit (Verbraucher);
// Nachdem das Programm 10 Sekunden lang ausgeführt wird, werden alle Aufgaben gestoppt
versuchen {
Thread.sleep (10000);
} catch (InterruptedException e) {
}
service.Shutdownnow ();
}
public static void main (String [] args) {
BlockingqueueTest.TestBasket ();
}
}