Si Bloquingqueue está lleno, cualquier operación que intente almacenar cosas se bloqueará y no se despertará para continuar las operaciones hasta que haya un nuevo espacio en Bloquingqueue.
Los principales métodos proporcionados por Blockingqueue son:
Agregar (Anobject): Agregue Anobject a la Bloquea.
Oferta (Anobject): Agregue Anobject a la Bloqueja.
Pon (Anobject): agregue Anobject a la Bloquea.
Encuesta (tiempo): Saque el objeto clasificado primero en Bloquingqueue. Devuelve nulo cuando no se puede recuperar.
Take (): Saque el objeto clasificado primero en Bloquingqueue.
Hay 4 implementaciones específicas de Bloquingqueue según las diferentes necesidades:
(1) ArrayBlockingqueue: el constructor del tamaño especificado debe tener un parámetro int para indicar su tamaño. Los objetos que contiene se clasifican en orden FIFO (primera entrada, primera vez).
(2) Linked Bockingqueue: Bloqueque con un tamaño variable.
Si el parámetro de tamaño no está incluido, el tamaño del bloqueo generado es determinado por Integer.Max_Value. Los objetos que contiene se clasifican en orden FIFO (primera entrada, primera vez).
En comparación con Linked Bloquingqueue y ArrayBlockingqueue, las estructuras de datos utilizadas detrás de ellas son diferentes.
El rendimiento de datos de Linked Bloquingqueue es mayor que el de ArrayBlockingqueue, pero su previsibilidad de rendimiento es menor que la de ArrayBlockingqueue cuando el número de subprocesos es grande.
(3) Priority Bockingqueue: Similar a LinkedBlokingqueue, pero la clasificación de objetos que contiene no es FIFO, pero está determinado por el orden de clasificación natural de los objetos o el orden determinado por el comparador traído por el constructor.
(4) Synchronousqueue: un Bloquingqueue especial, su funcionamiento debe completarse alternativamente colocando y obteniendo.
La copia del código es la siguiente:
paquete com.yao;
import java.util.concurrent.arrayblockingqueue;
import java.util.concurrent.blockingqueue;
import java.util.concurrent.executorservice;
import java.util.concurrent.executors;
clase pública BLOCKINGQUEUETEST {
/**
Definición de la canasta para Apple
*/
Cesta pública de clase estática {
// Cesta, capaz de contener 3 manzanas
Bloquingqueue <String> BASTINO = New ArrayBlockingqueue <String> (3);
// producir manzanas y ponerlas en una canasta
public void product () lanza interruptedException {
// Ponga una manzana en el método de poner.
Banker.put ("una manzana");
}
// consumir manzanas y sacarlas de la canasta
public string consumen () lanza interruptedException {
// El método Get saca una Apple.
Cadena Apple = Best.take ();
regresar manzana;
}
public int getApplenumber () {
return bank.size ();
}
}
// Método de prueba
public static void testBasket () {
// construir una canasta con manzanas
Canasta final = nueva canasta ();
// Defina el productor de Apple
El productor de clase implementa runnable {
public void run () {
intentar {
while (verdadero) {
// producir manzana
System.out.println ("El productor está listo para producir manzanas":
+ System.CurrentTimemillis ());
Bank.produce ();
System.out.println ("El productor ha terminado de producir manzanas":
+ System.CurrentTimemillis ());
System.out.println ("Después de la producción, hay manzanas:"+bestion.getApplenumber ()+");
// 300 ms de sueño
Thread.Sleep (300);
}
} capt (interruptedException ex) {
}
}
}
// Defina a los consumidores de Apple
implementos del consumidor de clase runnable {
public void run () {
intentar {
while (verdadero) {
// Consumo de manzana
System.out.println ("Los consumidores están listos para consumir Apple":
+ System.CurrentTimemillis ());
Bank.Consume ();
System.out.println ("El consumidor consume Apple"
+ System.CurrentTimemillis ());
System.out.println ("Después del consumo, hay manzanas:"+bestion.getApplenumber ()+");
// 1000 ms de sueño
Thread.sleep (1000);
}
} capt (interruptedException ex) {
}
}
}
EjecutorService Service = Ejecutors.NewCachedThreadPool ();
Productor productor = nuevo productor ();
Consumer Consumer = new Consumer ();
servicio.submit (productor);
servicio.submit (consumidor);
// Después de que el programa se ejecute durante 10 segundos, todas las tareas se detendrán
intentar {
Thread.sleep (10000);
} capt (interruptedException e) {
}
servicio.shutdownnow ();
}
public static void main (string [] args) {
BLOCKINGQUEUETEST.TESTBASKET ();
}
}