LinkedBlockingQueue:
fuente:
Tamaño / ** bloqueo de cola, el valor predeterminado es Integer.MAX_VALUE * / int capacidad final privado; / ** bloqueo actual número de elementos en la cola * / recuento final privado AtomicInteger = new AtomicInteger ();
* La cabeza de la cola de bloqueo de la unión transitoria de nodo <E> cabeza; * el bloqueo de nodo de la cola cola transitoria privada Nodo <E> última; / ** quitar bloqueo adquieren cuando los elementos tales como toma, encuesta, etc. * / privada última ReentrantLock takeLock = new ReentrantLock ();
características:
1: Si no se especifica una capacidad que por defecto es Integer.MAX_VALUE (valor predeterminado: Si se agrega una mayor velocidad que la velocidad de eliminación cuando existe, es posible que se quede sin memoria), que es la cola sin límites. Por lo tanto, con el fin de evitar las colas causado por el exceso de la memoria de la máquina a plena carga o parecer.
2: Se añade Cada datos a la cola LinkedBlockingQueue nodo se encapsula en el nodo, añadiendo la lista de la cola en la que la cabeza y el último punto al nodo de cabeza y cola de nodo de cola.
3: inkedBlockingQueue interior se utilizaron takeLock y putLock control de concurrencia, es decir, añadir, y operaciones de borrado no son mutuamente exclusivos operaciones se pueden realizar de forma simultánea, de modo que pueda mejorar en gran medida el rendimiento
método de puesta en cola
vacío put (s S) Características:
1: la cola está llena, el bloque de espera.
2: La cola no está llena, crear un nodo nodo en la cola después de colas está hecho y si hay espacio a la izquierda, junto a seguir despertar añaden añadió un hilo. Si la cola no se pone delante de los elementos, se realiza para despertar después de que el consumo de hilo consumidor.
pública de venta sin efecto (E e) lanza InterruptedException {if (e == null) throw new NullPointerException (); int c = -1; Nodo <E> = nodo nuevo nodo <E> (e); ReentrantLock última putLock = esto. putLock; AtomicInteger recuento final = this.count; // adquirir el bloqueo de interrupción putLock.lockInterruptibly (); try {// si la cola está llena, si está lleno de espera de bloqueo, mientras que (count.get () == capacidad) {notFull. await ();} // nodo en la cola de enqueue (nodo); c = count.getAndIncrement (); // cola se determina de nuevo si hay espacio disponible, si hay una operación de rosca despierto add si (c + 1 <capacidad) notFull.signal ();} finally {putLock.unlock ();} // si hay una cola de datos, el consumo de hilo de activación para el consumo si (c == 0) signalNotEmpty ();}
private void signalNotEmpty () {definitiva ReentrantLock takeLock = this.takeLock; takeLock.lock (); try {notEmpty.signal (); } Finally {takeLock.unlock (); }} SignalNotFull private void () {definitiva ReentrantLock putLock = this.putLock; putLock.lock (); try {notFull.signal (); } Finally {putLock.unlock (); }}
oferta booleano (e E) Características:
Cuando el elemento de la cola no está disponible, esperando método put es diferente de la obstrucción, la oferta método directo Método falsa.
oferta pública booleano (E e) {if (e == null) throw new NullPointerException (); AtomicInteger recuento final = this.count; si (count.get () == capacidad) falso retorno; int c = -1; Nodo <e> nodo = nuevo nodo <e> (e); definitiva ReentrantLock putLock = this.putLock; putLock.lock (); try {// el espacio de cola está disponible, el nodo en el nodo determina si hay elementos en espacio disponible, // si es así, añadir una estela de hilo hasta la siguiente adición. si (count.get () <capacidad) {enqueue (nodo); c = count.getAndIncrement (); si (c + 1 <capacidad) notFull.signal ();}} finally {putLock.unlock ();} si (c == 0) signalNotEmpty (); retorno c> = 0;}
oferta booleano (E e, largo tiempo de espera, la unidad TimeUnit) 特点:
Para ofrecer un método de bloquear el manejo de tiempo de espera, utilice la condición de awaitNanos que esperar un tiempo muerto, ¿por qué utilizar un bucle while aquí? Debido método awaitNanos es interrumpible, con el fin de evitar que durante el hilo de espera se interrumpe, utilizar un bucle while aquí esperando para el procesamiento durante la interrupción, el resto siga esperando que esperar mucho
método dequeue
E toma () Características de:
1: la cola está vacía, el bloque de espera.
2: La cola no está vacía, el primer equipo de Recupera y elimina un elemento, una eliminación elemento hilo consumidor bajo post-consumidor si hay elementos en la cola, siguen despertar. Si se pone el caso ante la cola está llena de elementos retirados después de su uso a elementos estela Añadir el tema productos.
E pública toma () lanza InterruptedException {x E; int c = -1; AtomicInteger recuento final = this.count; ReentrantLock última takeLock = this.takeLock; takeLock.lockInterruptibly (); try {// cola está vacía, mientras que el bloqueo de espera (count.get () == 0) {notEmpty.await ();} x = dequeue (); c = count.getAndDecrement (); // hay elementos en la cola, el siguiente despertador un consumo de hilo para el consumo si (c > 1) notEmpty.signal ();} finally {takeLock.unlock ();} // elementos quitan antes de que la cola está llena, hilo producción despertar elemento aditivo si (c == capacidad) signalNotFull (); return x; }
sondeo E ():
E encuesta pública () {AtomicInteger recuento final = this.count; si null (count.get () == 0) return; E x = null; int c = -1; última ReentrantLock takeLock = this.takeLock; takeLock.lock (); try {si (count.get ()> 0) {x = dequeue (); c = count.getAndDecrement (); si (c> 1) notEmpty.signal (); }} Finally {takeLock.unlock (); } If (c == capacidad) signalNotFull (); retorno X; }
sondeo E (largo tiempo de espera, la unidad TimeUnit);
eliminar (): método de los elementos Delete
remove pública booleano (Object o) {if (o == null) falso retorno; // dos de bloqueo bloqueado todo fullyLock (); try {// atraviesan desde el elemento de cabeza, hasta el último elemento para (Nodo <E> rastro = cabeza, p = trail.next ;! p = null; sendero = p, p = p.next) {// Si encontró elementos iguales, llamando a un método para eliminar los elementos desvincular si (o.equals (p.item)) {unlink (p, tRAIL); return true;}} return false;} finally {// desbloqueo dos cerradura todo fullyUnlock ();}}
-------------------------------------------------- -------------------------------------------------- -----------------------
ArrayBlockingQueue:
método Enqueue:
1: add: Oferta consigue realmente dentro del método, cuando la cola está llena, lanzar una IllegalStateException ( "cola llena") excepción no bloquea.
2: Oferta: cola llena, devuelve true y false retorno cuando la cola está llena. No bloquea el retorno inmediato.
, // ArrayBlockingQueue # ofrecer rendimientos la cola completos cierto, vuelve falsa oferta pública booleano (E e) {checkNotNull (e) al completo; // Comprobar si el elemento es poner en cola vacía bloqueo ReentrantLock final = this.lock; lock.lock (); // obtener el bloqueo, intenta flujos seguros {if (count == items.length) // cuando la cola está llena, no bloquee la espera de un retorno directo falsa falsa retorno; else {inserto (e); // cola no está llena, directamente en el retorno verdadera;}} finally {lock.unlock ();}}
oferta (correo, el tiempo, la unidad): establece el tiempo de espera, si los datos no pueden ser insertados en la cola dentro de los retornos de tiempo especificados falsos retornos de inserción, exitosas verdaderos.
3: put: cuando la cola no está llena, no directamente en el valor de retorno; bloqueará cola de espera está llena, espera entonces insertado hasta que la cola no está llena.
// ArrayBlockingQueue # put
pública de venta sin efecto (E e) {lanza InterruptedException
checkNotNull (e); // también comprobar si el elemento de inserción está vacía
cerradura ReentrantLock final = this.lock;
lock.lockInterruptibly (); // método de bloqueo no se llama aquí, pero las llamadas se puede interrumpir lockInterruptibly, que pueden ser interrumpidas hilos de retorno, bloqueo no puede ser interrumpido para el retorno.
tratar {
mientras que (recuento == items.length)
notFull.await (); // Cuando la cola está llena, por lo que la cola del sueño no es completa
insertar (e); // este caso representa la cola no está llena, se inserta en el elemento, mientras que la cola no vacía en la estela del método en
} finalmente {
bloqueo y desbloqueo();
}
}
método de quitar de la cola:
1: remove (): Cuando la cola no está vacía, el valor de retorno del primer equipo y eliminado; cola está vacía tiro NoSuchElementException () excepción
// AbstractQueue # remove, y este es un método de la plantilla, los algoritmos de deleción definida esqueleto elemento de la cola, y devuelve el elemento específico en el elemento de la cola, el elemento está vacío, se produce una excepción, la encuesta implementación específica implementada por subclases,
E pública remove () {
E x = poll (); // sondear los métodos de interfaz definidos por la Cola
si (x! = null)
retorno X;
más
arrojar nueva NoSuchElementException ();
}
2: cola de retorno no está vacía cuando el valor del primer equipo y eliminado; devuelva null cola está vacía: poll (). No bloquea el retorno inmediato.
// ArrayBlockingQueue # sondeo, devuelve todos los elementos en el elemento de la cola, no vuelve nula encuesta pública E () {cerradura ReentrantLock final = this.lock está vacía; lock.lock (); try {return (recuento == 0)? null: extracto ();} finally {lock.unlock ();}}
// ArrayBlockingQueue # extracto extracto E privada () {objeto final [] artículos = this.items; E x = Este <E> Reparto (artículos [takeIndex]) ;. // quitar la cabeza de los elementos de elementos de cola de [takeIndex] = null ; // establecer el primer elemento de la matriz de colas es nulo, GC facilitar la recuperación takeIndex = inc (takeIndex); --count; notFull.signal (); // cola de espera no es completo hilo wake-retorno x;}
sondeo (tiempo, unidad): establecer el tiempo de espera, si la cola tiene no se devuelve nulo agujero dentro del tiempo especificado, el equipo no está vacía, entonces devuelve el primer valor
3: Toma (e): la primera cola no está vacía equipo de valor de retorno y se retira; cuando la cola está bloques vacíos de la espera, espera hasta que la cola no está vacía, entonces volver a los primeros valores de equipo.
// # ArrayBlockQueue tomar tomar E pública () {lanza InterruptedException bloqueo ReentrantLock final = this.lock (); lock.lockInterrupted (); // este método no se llama a la cerradura, pero la llamada puede ser interrumpida en lockInterruptibly, que el método interrupciones de rosca pueden ser devueltos, la cerradura no puede ser interrumpido a cambio. try {while (contar == 0) // cola elemento es notEmpty.await vacía (); // esperar cola no está vacía extracto de retorno del sueño (); // este caso representa una cola no está vacía, se elimina el elemento, mientras que en la estela no llena cola} finally {lock.unlock ();}}
Pequeña expansión:
tamaño int público () {cerradura ReentrantLock final = this.lock; lock.lock (); try {recuento de retorno; } Finally {lock.unlock (); }}
El tamaño de la cola método ArrayBlockingQueue, variable de recuento se devuelve directamente, a diferencia de ConcurrentLinkedQueue, tamaño ConcurrentLinkedQueue de la cola atravesará cada vez, por lo que el tamaño método ArrayBlockingQueue más alta que la eficiencia ConcurrentLinkedQueue método tamaño.
size () () método lleva más tiempo que estaVacia, porque el tamaño () para iterar sobre la colección.
SynchronousQueue
1: es ilimitado, es un tampón de cola no espera, que cada inserto estará esperando otros hilos correspondientes a la operación de retirada, y viceversa. SynchronousQueue tales productores y consumidores para unirse al canal, es más adecuado para la "conmutación" o "paso" este escenario: un hilo debe esperar a que otro hilo a la entrega de información de sincronización / hora / tarea a ella;
2: No capacidad SynchronousQueue interna no puede ser adquirido por un método de elemento de cabecera peek; elemento por sí sola no puede ser insertado, se puede simplemente entendida como la inserción y la extracción son "un par" operación simétrica. Para la compatibilidad con ciertas operaciones de recogida de (por ejemplo, contiene), SynchronousQueue desempeñó el papel de un conjunto vacío.
Un escenario típico es SynchronousQueue en el grupo de subprocesos, Executors.newCachedThreadPool () en el uso de ella, la estructura del grupo de subprocesos (cuando las nuevas tareas vienen) crear nuevos temas, según sea necesario, si hay un hilo vacío se volverá a utilizar, hilo se recicla después de estar inactivo durante 60 segundos.
3: SynchronousQueue política de imparcialidad opcional para el proceso de espera de productores o consumidores de hilos (el modo no equidad defecto). pila de modo desleal (LIFO) para lograr modo razonable se logra mediante una cola (FIFO). estructuras de datos utilizadas doble cola (cola Dual) y una pila dual (pila Dual), FIFO utiliza típicamente para apoyar el rendimiento más alto, hilo soportes LIFO superior de almacenamiento local (TLS).
SynchronousQueue bloqueo algoritmo se puede resumir de la siguiente manera:
1: el uso de cola doble (cola Dual) y una pila dual (pila dual) para almacenar datos, cada nodo en la cola puede ser un productor o consumidor.
2: Cancelado punto de referencia nodo a sí mismo, a la retención de evitar la basura y la pérdida de memoria
3: bloqueo alcanzado por el giro y el parque LockSupport / anular el estacionamiento, en un entorno de alta contención, el rendimiento puede ser significativamente mejorada giro.
Hay tres clases internas SynchronousQueue
1: Transferer: clase abstracta interna, solamente un método de transferencia. SynchronousQueue se ponen o tomar un proceso unificado (este es el método de transferencia), ya que la estructura de datos de colas / pila dual, de suelta y operaciones son simétricas, por lo que casi todo el código se puede combinar.
fuente:
pública de venta sin efecto (E e) lanza InterruptedException {if (e == null) throw new NullPointerException (); si (transferer.transfer (e, falso, 0) == null) {Thread.interrupted (); arrojar nueva InterruptedException (); }}
2: TransferStack: hereda abstractos clase Transferer interna, para lograr un método de transferencia para una operación de cola en un modo de no justo, en el orden de los datos LIFO. De doble pila dentro de la lista de manera vinculada Snøde lograr.
modo)) {// nodo principal no ha sido igualado, intenta hacer coincidir tratar de cumplir si (h.isCancelled ()) // ya cancelado // cabeza ha sido emparejado, cabeza modificado sigue bucle casHead (h, h.next); // // pop y reintento construir el nuevo nodo en la pila else if (casHead (h, s = Snøde (s, e, h, cumpliendo | modo))) {for (;;) {// bucle hasta emparejado o camareros desaparecen // cas s nodo después de un partido de éxito es s.next, es decir, m Snøde m = s.next; // m es fósforo de s si (m == null) {// todos los camareros se han ido casHead (s, null); // pop cumplir nodo s = null; // utilizar nuevo nodo siguiente pausa tiempo; // reinicie bucle principal Snøde} Mn = m.next; si (m.tryMatch (s)) {// tratar de igualar, despertar enhebrar m nodo casHead (s, mn); // pop exitosos que coinciden dos nodos, la cabeza del reemplazo estallido ambos s y m retorno (e) :;} ((modo == petición) m.item s.item?) else // partido perdido s.casNext (m, mn); // comparación falla, borrar el nodo m, recirculación ayuda unlink}}} else {// el primer nodo se corresponde ayuda un cumplidor Snøde m = h.next; // m es partido de h si (m == null) // camarero es dinero en efectivo se ha ido ead (h, null); // pop nodo satisfactoria else {// 帮助 头 节点 匹配 Snøde mn = m.next; si (m.tryMatch (h)) // ayuda partido casHead (h, mn); // pop ambos H y M else // suelto partido h.casNext (m, mn); // ayuda de desenlace}}}}
Descripción: El algoritmo básico es uno de los tres ciclos de tratar los siguientes comportamientos:
1: Si la pila está vacía o que ya contiene un modo idéntico, en este momento son dos casos: Si una operación que no se cuenten (oferta, sondeo) o ha expirado, el nulo retorno directo; en otros casos, la opción de venta nodo actual en la espera pila prensada coincidir (por el método awaitFulfill), un partido se devuelve nodos elemento coincidente, si un nodo cancelar llamada en espera en el método limpia (explicado más adelante por separado) para borrar el nodo de espera para cancelar y nulo de retorno.
2: Si el nodo pila (cabeza) no se ha emparejado (determinado por el método isFulfilling), poner en nodo actual pila, y los nodos de intentar coincidir con la cabeza, los dos nodos emparejados expulsado con éxito de la pila, y devuelve el nodo coincidente datos. isFulfilling código fuente como sigue:
/ ** Devuelve cierto si m ha establecido el bit de cumplimiento. * / Static boolean isFulfilling (int m) {return (M & CUMPLIENDO) = 0; }
3: Si la parte superior de la pila nodo (cabeza) ya tiene otro nodo de datos, lo que indica que el nodo de pila es una coincidencia, el cruce de operaciones para ayudar a este nodo, a continuación, iniciar el ciclo continúa desde el primer paso.
3: TransferQueue: hereda clase abstracta Transferer interna, para lograr un método de transferencia para el modo de operación de cola justo, en el orden de los datos de FIFO. A modo ligado cola de la lista logra QNode interna dual.
Fuente: Transferencia de Correo (E e, boolean cronometrado, nanos largos) {QNode s = null; // construida / reutilizada como sea necesario booleano ISDATA = (! E = null); // ponga analizar o dar por (;;) {QNode t = cola; QNode h = cabeza; si (t == null || h == null) // sierra valor no inicializado continuar; // centrifugado, si (h == t || t.isData == ISDATA) {// vaciar o del mismo modo QNode tn = t.next; if (! t = cola) // lectura inconsistente continuar; if (! tn = null) {// nodo de cola histéresis, actualizar el nodo de cola quedando cola advanceTail (t, tn) ; continuar;} if (cronometrada && nanos <= 0) // no puede esperar return null; // configuración actual de funcionamiento del nuevo nodo, y en la cola si (s == null) s = new QNode (e, ISDATA); (! t.casNext (nulo, s) si) // fallado en eslabón de continuar; // avance cola advanceTail (t, s); // cola media vuelta y partido espera // espera, y vuelve al nodo emparejado de artículo, si este nodo espera cancelados s Object x = awaitFulfill (s, e, temporizada, nanos) return; si (x == s) {// espera fue cancelada limpio (t, s); // espera a ser cancelada, claro s nodo devuelto nulo;} if (s !.isOffList ()) {// s nodo aún no ha quitado de la cola no ya desvinculado advanceHead (t, s); // unlink si la cabeza si (x = null) // y olvidar campos s.item = s ;! // elemento a sí mismo s.waiter = null;} return (x! = null) (e) x: e; // tomar} else {// complementaria modo QNode m = h.next; // nodo a cumplir si (t = ?! ! cola || m == null || h = cabeza) continuar; // inconsistente lectura Object x = m.item; if (! ISDATA == (x = null) || // m ya cumplida x == m | | //m.item=m, m cancelado m.casItem (x, e)) {// partido, CAS modificado artículo para el elemento dado e perdido CAS advanceHead (h, m) ;! // cabeza de propulsión, continúan después de encontrar el dequeue y reintento continuar;} advanceHead (h, m); // éxito partido, cabeza quitadas de la cola cumplido con éxito LockSupport.unpark (m.waiter); // nodo m wakeup se corresponde retorno de hilo (! x = null) ? (e) x: e;}}}?} Retorno (E) x (X! = Null): e; // para llevar} else {// modo complementario QNode m = h.next; // nodo a cumplir si (t = cola || m ==! ! nulo || h = cabeza) continuar; // inconsistente lectura Object x = m.item; (! ISDATA == (x = null) si || // m ya cumplida x == m || //m.item ! = m, m cancelado m.casItem (x, e)) {// partido, CAS modificado elemento para el elemento dado correo perdido CAS advanceHead (h, m); // cabeza antelación, sigue a mirar hacia atrás y quitar de la cola de reintento continúan ?;} advanceHead (h, m); // éxito partido, cabeza quitadas de la cola cumplido con éxito LockSupport.unpark (m.waiter); // nodo m wakeup se corresponde retorno de hilo (x = null!) (E) x: e;}}}?} Retorno (E) x (X! = Null): e; // para llevar} else {// modo complementario QNode m = h.next; // nodo a cumplir si (t = cola || m ==! ! nulo || h = cabeza) continuar; // inconsistente lectura Object x = m.item; (! ISDATA == (x = null) si || // m ya cumplida x == m || //m.item ! = m, m cancelado m.casItem (x, e)) {// partido, CAS modificado elemento para el elemento dado correo perdido CAS advanceHead (h, m); // cabeza antelación, sigue a mirar hacia atrás y quitar de la cola de reintento continúan ?;} advanceHead (h, m); // éxito partido, cabeza quitadas de la cola cumplido con éxito LockSupport.unpark (m.waiter); // nodo m wakeup se corresponde retorno de hilo (x = null!) (E) x: e;}}}e)) {// partido, CAS modificado elemento para el elemento dado correo perdido CAS advanceHead (h, m); // cabeza antelación, sigue a mirar hacia atrás y quitar de la cola de reintento Continuar;} advanceHead (h, m); // Partido éxito, cabeza quitadas de la cola cumplido con éxito LockSupport.unpark (m.waiter); (! x = null) // nodo m wakeup se corresponde retorno de hilo (e) x :? e;}}}e)) {// partido, CAS modificado elemento para el elemento dado correo perdido CAS advanceHead (h, m); // cabeza antelación, sigue a mirar hacia atrás y quitar de la cola de reintento Continuar;} advanceHead (h, m); // Partido éxito, cabeza quitadas de la cola cumplido con éxito LockSupport.unpark (m.waiter); (! x = null) // nodo m wakeup se corresponde retorno de hilo (e) x :? e;}}}
Descripción: El algoritmo básico es uno de los dos ciclos a través de las siguientes acciones:
1: Si la cola está vacía o un nodo de cola en la cola (cola) y su mismo modo, se añade el nodo actual para poner el final de la cola, a la espera de llamada nodo awaitFulfill es igualada. El partido de vuelta está emparejando elemento del nodo, si el nodo es retornos de tiempo de espera de espera interrumpidas o nula. Mientras tanto vamos a seguir para comprobar el nodo de cola, si el nodo de cola es modificado por otros hilos, y luego continuar con el ciclo de la cola de propulsión hacia atrás.
Nota: TransferQueue del método awaitFulfill consistente con TransferStack.awaitFulfill algoritmo, la parte de atrás ya no se explica.
2: si el modo actual de funcionamiento del nodo de cola (cola) son diferentes, entonces puede ser igualada, el nodo de cabeza de la cabeza de la cola para empezar a buscar hacia atrás que coincida con una nodos complementarios, los nodos intentan modificar el elemento de campo CAS complementaria por el elemento E dado, Si un partido está avanzando hacia atrás la cabeza, y se despierta el hilo camarero nodo coincidente, y los nodos artículo encontrado finalmente devueltos.
pila comparativo / despacho nodo de cola (Metodo de limpieza)
1: Para la cola, si el nodo es cancelada, podemos se elimina casi siempre grado complejo tiempo-O1 de un nodo. Sin embargo, si el nodo en la cola, debe esperar cancela fuera de plazo nodo.
2: Para la pila, es posible que complejidad de tiempo de O (n) para atravesar toda la pila, y luego determinar el nodo se puede quitar, pero otros hilos pueden acceder a la pila y se ejecutan en paralelo.
-------------------------------------------------- -------------------------------------------------- -----------------------
resumen:
LinkedBlockingQueue está bloqueando una cola internamente por dos ReentrantLock para lograr flujos seguros y fuera de la cola, implementado por los respectivos objetos de condición de espera esperar, y al de la señal y las funciones de despertador. Difiere en que ArrayBlockingQueue:
- tamaño de la cola es diferente, inicializar ArrayBlockingQueue con un tamaño limitado debe ser especificada, pero puede estar delimitado LinkedBlockingQueue puede ser ilimitada (Integer.MAX_VALUE), para el segundo, cuando la velocidad de adición es mayor que la velocidad de eliminación, en el caso de sin límites puede causar desbordamiento de la memoria y otros problemas.
- Different recipiente de almacenamiento de datos, utilizando la matriz como ArrayBlockingQueue con el envase de almacenamiento de datos, y LinkedBlockingQueue se basa empleado como un nodo de lista enlazada objetos de nodo.
- Puesto que el recipiente de almacenamiento se utiliza array ArrayBlockingQueue, de modo que no adicional o destruir cualquier elemento de instancia de objeto insertado o eliminado, sino un objeto adicional LinkedBlockingQueue nodo generar. Se puede tomar una hora larga
- Cuando se procesa simultáneamente efecto de grandes cantidades de datos, puede haber un impacto mayor para GC.
- Lograr tanto añadir o eliminar cola de bloqueo no es la misma, la cola se implementa ArrayBlockingQueue bloqueo no está aislado, se añade con una operación de bloqueo y retirar emplea ReenterLock operación, mientras que la cola de bloqueo se implementa LinkedBlockingQueue separada , que se utiliza para agregar putLock, se utiliza para eliminar takeLock, esto puede aumentar en gran medida el rendimiento de la cola, significa que los productores y consumidores pueden operar en la cola de datos en paralelo en el caso de alta concurrente a esta concurrencia para mejorar el rendimiento global de las colas.
