Filas sem Bloqueio
Implementações de fila seguras para threads e, o mais importante, sem bloqueio em nós vinculados.
ConcurrentLinkedQueue<E> - usa um algoritmo sem espera adaptado para trabalhar com o coletor de lixo. Este algoritmo é bastante eficiente e muito rápido, pois é construído sobre o CAS. O método size() pode ser executado por um longo período de tempo, portanto, é melhor não puxá-lo o tempo todo.
ConcurrentLinkedDeque<E> - Deque significa Fila dupla. Isso significa que os dados podem ser adicionados e extraídos de ambos os lados. Assim, a classe suporta ambos os modos de operação: FIFO (First In First Out) e LIFO (Last In First Out).
Na prática, ConcurrentLinkedDeque deve ser utilizado caso o LIFO seja absolutamente necessário, pois devido à bidirecionalidade dos nós, esta classe perde metade do desempenho em relação a ConcurrentLinkedQueue .
import java.util.concurrent.ConcurrentLinkedQueue;
public class ConcurrentLinkedQueueExample {
public static void main(String[] args) {
ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<>();
Thread producer = new Thread(new Producer(queue));
Thread consumer = new Thread(new Consumer(queue));
producer.start();
consumer.start();
}
}
class Producer implements Runnable {
ConcurrentLinkedQueue<String> queue;
Producer(ConcurrentLinkedQueue<String> queue){
this.queue = queue;
}
public void run() {
System.out.println("Class for adding items to the queue");
try {
for (int i = 1; i < 5; i++) {
queue.add("Item #" + i);
System.out.println("Added: Item #" + i);
Thread.sleep(300);
}
} catch (InterruptedException ex) {
ex.printStackTrace();
Thread.currentThread().interrupt();
}
}
}
class Consumer implements Runnable {
ConcurrentLinkedQueue<String> queue;
Consumer(ConcurrentLinkedQueue<String> queue){
this.queue = queue;
}
public void run() {
String str;
System.out.println("Class for getting items from the queue");
for (int x = 0; x < 5; x++) {
while ((str = queue.poll()) != null) {
System.out.println("Pulled out: " + str);
}
try {
Thread.sleep(600);
} catch (InterruptedException ex) {
ex.printStackTrace();
Thread.currentThread().interrupt();
}
}
}
}
Bloqueio de Filas
Interface BlockingQueue<E> - se houver muitos dados, ConcurrentLinkedQueue não será suficiente.
Quando os threads falham em fazer seu trabalho, você pode facilmente obter um OutOfMemmoryException . E para que esses casos não ocorram, temos um BlockingQueue para trabalhar com a presença de diferentes métodos de preenchimento e trabalho com a fila e bloqueios condicionais.
BlockingQueue não reconhece elementos nulos e lança um NullPointerException ao tentar adicionar ou obter tal elemento. O método poll retorna um elemento nulo se nenhum elemento foi colocado na fila dentro do tempo limite.
Implementações BlockingQueue<E>
Vamos dar uma olhada em cada uma de nossas implementações BlockingQueue :
ArrayBlockingQueue<E> é uma classe de fila de bloqueio criada no buffer de anel clássico. Aqui temos a oportunidade de gerir a “honestidade” das fechaduras. Se justo=falso (o padrão), a ordem do encadeamento não é garantida.
DelayQueue<E extends Delayed> é uma classe que permite puxar elementos da fila somente após um certo atraso, definido em cada elemento através do método getDelay da interface Delayed .
LinkedBlockingQueue<E> é uma fila de bloqueio em nós vinculados, implementada no algoritmo “two lock queue”: o primeiro bloqueio é para adicionar, o segundo é para puxar um elemento da fila. Devido aos bloqueios, em comparação com ArrayBlockingQueue , esta classe tem alto desempenho, mas requer mais memória. O tamanho da fila é definido por meio do construtor e é igual a Integer.MAX_VALUE por padrão.
PriorityBlockingQueue<E> é um wrapper multiencadeado sobre PriorityQueue . O Comparator é responsável pela lógica pela qual o elemento será adicionado. O menor elemento sai primeiro.
SynchronousQueue<E> - a fila funciona de acordo com o princípio FIFO (first-in-first-out). Cada operação de inserção bloqueia o thread “Produtor” até que o segmento “Consumidor” puxe o elemento da fila e vice-versa, o “Consumidor” aguardará até que o “Produtor” insira o elemento.
BlockingDeque<E> é uma interface que descreve métodos adicionais para uma fila de bloqueio bidirecional. Os dados podem ser inseridos e retirados de ambos os lados da fila.
LinkedBlockingDeque<E> é uma fila de bloqueio bidirecional em nós vinculados, implementada como uma lista bidirecional simples com um bloqueio. O tamanho da fila é definido por meio do construtor e é igual a Integer.MAX_VALUE por padrão.
TransferQueue<E> - a interface é interessante porque, quando um elemento é adicionado à fila, é possível bloquear a inserção do encadeamento do produtor até que outro encadeamento do consumidor extraia o elemento da fila. Você também pode adicionar uma verificação para um tempo limite específico ou definir uma verificação para Consumer s pendentes . Como resultado, obtemos um mecanismo de transferência de dados com suporte para mensagens assíncronas e síncronas.
LinkedTransferQueue<E> é uma implementação de TransferQueue baseada no algoritmo Dual Queues with Slack. Faz uso intenso de CAS (veja acima) e thread parking quando ocioso.