Blockingqueue

Introducción a BlockingQueue

En Java, una BlockingQueue es una estructura de datos concurrente que almacena elementos en un orden específico y permite operaciones seguras entre múltiples hilos (threads). Combina las características de una cola FIFO con mecanismos de bloqueo, lo que la convierte en una herramienta esencial para resolver problemas de concurrencia, como los patrones Productor-Consumidor.

---

🚀 Conceptos Clave

1. Cola FIFO

• Las colas funcionan bajo el principio First In, First Out (primero en entrar, primero en salir).
• El primer elemento que se agrega a la cola es el primero en ser recuperado.

2. Bloqueo (Blocking)

• Si un hilo intenta obtener un elemento de una cola vacía, se bloquea hasta que un elemento esté disponible.
• Si un hilo intenta agregar un elemento a una cola llena, se bloquea hasta que haya espacio disponible.

3. Seguridad de Hilos (Thread Safety)

• Las BlockingQueue garantizan la seguridad en operaciones concurrentes, evitando el uso explícito de sincronización con synchronized o Lock.

---

🏗️ Jerarquía de Interfaces y Clases en Java

java.util.Queue
  ↳ java.util.concurrent.BlockingQueue<E>
    ↳ java.util.concurrent.TransferQueue<E> (extiende funcionalidades)
    ↳ java.util.concurrent.BlockingDeque<E> (doble extremo)

---

🛠️ Principales Implementaciones de BlockingQueue

Implementación	Descripción
ArrayBlockingQueue	Cola de tamaño fijo basada en arrays. Acotada, mantiene los elementos en orden FIFO.
LinkedBlockingQueue	Cola basada en listas enlazadas. Puede ser acotada o no acotada. Tiene mejor rendimiento en operaciones con muchos productores/consumidores.
PriorityBlockingQueue	Cola no FIFO, donde los elementos se ordenan según el orden natural o un comparador.
DelayQueue	Solo permite retirar elementos después de un tiempo determinado (útil para tareas programadas).
SynchronousQueue	Cola de capacidad cero. Cada put debe esperar un take y viceversa. Sin almacenamiento intermedio.
LinkedBlockingDeque	Cola doble extremo (Deque). Permite insertar y eliminar desde ambos extremos. Ideal para escenarios de control avanzado de flujo.
LinkedTransferQueue	Transferencia directa de elementos de productor a consumidor. Ofrece mayor control sobre la sincronización en las transferencias.

---

⚙️ Operaciones Principales de BlockingQueue

Método	Descripción
void put(E e)	Agrega el elemento a la cola. Bloquea si la cola está llena.
E take()	Recupera y elimina el elemento de la cabeza. Bloquea si la cola está vacía.
boolean offer(E e)	Intenta agregar el elemento. Retorna false si la cola está llena. No bloquea.
E poll()	Recupera y elimina el primer elemento. Retorna null si la cola está vacía. No bloquea.
E peek()	Recupera el primer elemento sin eliminarlo. Retorna null si la cola está vacía.
Métodos con Timeout	offer(E e, long timeout, TimeUnit unit) o poll(long timeout, TimeUnit unit). Espera un tiempo antes de rendirse en la operación.

---

🎨 Diagrama Conceptual

Productor (put) ───► BlockingQueue ◄─── (take) Consumidor
                        ▲      ▲
        Bloqueo si lleno │      │ Bloqueo si vacío

---

🔨 Ejemplo Práctico: Productor-Consumidor con ArrayBlockingQueue

import java.util.concurrent.*;

public class BlockingQueueDemo {

    private static final int QUEUE_CAPACITY = 5;
    private static final BlockingQueue<Integer> taskQueue = new ArrayBlockingQueue<>(QUEUE_CAPACITY);

    public static void main(String[] args) {

        Thread producer = new Thread(() -> {
            try {
                for (int i = 1; i <= 20; i++) {
                    taskQueue.put(i); // Bloquea si está lleno
                    System.out.println("Productor produjo: " + i);
                    Thread.sleep(100); // Simula tiempo de producción
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        Runnable consumerTask = (/*nombre del consumidor*/) -> {
            String consumerName = Thread.currentThread().getName();
            try {
                while (true) {
                    Integer task = taskQueue.take(); // Bloquea si vacío
                    System.out.println(consumerName + " consumiendo tarea: " + task);
                    Thread.sleep(1000); // Simula tiempo de procesamiento
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        };

        Thread consumer1 = new Thread(() -> consumerTask.run(), "Consumidor-1");
        Thread consumer2 = new Thread(() -> consumerTask.run(), "Consumidor-2");

        producer.start();
        consumer1.start();
        consumer2.start();
    }
}

---

📌 TransferQueue: Transferencia Directa

TransferQueue extiende BlockingQueue para permitir que los productores esperen hasta que un consumidor reciba el elemento directamente.

TransferQueue<String> transferQueue = new LinkedTransferQueue<>();

// Productor
new Thread(() -> {
    try {
        System.out.println("Intentando transferir mensaje...");
        transferQueue.transfer("Mensaje importante");
        System.out.println("Transferencia completada.");
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}).start();

// Consumidor
new Thread(() -> {
    try {
        String msg = transferQueue.take(); // Recibe directamente
        System.out.println("Mensaje recibido: " + msg);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}).start();

---

📝 Recomendaciones de Uso

1. ArrayBlockingQueue
   • Escenario: Capacidad conocida y limitada.
   • Uso: Alta eficiencia y predictibilidad.
2. LinkedBlockingQueue
   • Escenario: Tamaños dinámicos, muchos productores y consumidores.
   • Uso: Mejor rendimiento en sistemas multi-hilo.
3. PriorityBlockingQueue
   • Escenario: Procesamiento basado en prioridades.
4. DelayQueue
   • Escenario: Planificación y ejecución diferida de tareas.
5. SynchronousQueue
   • Escenario: Transferencia directa, sin almacenamiento intermedio.

---

🔍 Buenas Prácticas

• Evita el uso de while(true) sin condiciones de parada controladas. Considera mecanismos de interrupción para detener hilos.
• Gestiona correctamente las excepciones InterruptedException en ambientes concurrentes.
• Elige la implementación correcta según el patrón de uso (Productor-Consumidor, priorización de tareas, etc.).
• Prueba el rendimiento con varios escenarios (muchos hilos, diferentes capacidades).

---

📚 Lecturas Adicionales

• Documentación Oficial de BlockingQueue
• Libro: Java Concurrency in Practice de Brian Goetz.
• Patrones de concurrencia: Productor-Consumidor, Work Stealing, Thread Pool Executor.

---