Code simultanee

Code non bloccanti

Implementazioni della coda thread-safe e, soprattutto, non bloccanti sui nodi collegati.

ConcurrentLinkedQueue<E> : utilizza un algoritmo senza attesa adattato per funzionare con il Garbage Collector. Questo algoritmo è abbastanza efficiente e molto veloce, poiché è basato su CAS. Il metodo size() può essere eseguito per molto tempo, quindi è meglio non estrarlo continuamente.

ConcurrentLinkedDeque<E> - Deque sta per Double ended queue. Ciò significa che i dati possono essere aggiunti ed estratti da entrambi i lati. Di conseguenza, la classe supporta entrambe le modalità operative: FIFO (First In First Out) e LIFO (Last In First Out).

In pratica, ConcurrentLinkedDeque dovrebbe essere utilizzato se LIFO è assolutamente necessario, poiché a causa della bidirezionalità dei nodi, questa classe perde la metà delle prestazioni rispetto 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();
           }
       }
   }
}

Code di blocco

Interfaccia BlockingQueue<E> : se sono presenti molti dati, ConcurrentLinkedQueue non è sufficiente.

Quando i thread non riescono a svolgere il loro lavoro, puoi facilmente ottenere un OutOfMemmoryException . E affinché tali casi non si verifichino, abbiamo un BlockingQueue per lavorare con la presenza di diversi metodi per riempire e lavorare con la coda e i blocchi condizionali.

BlockingQueue non riconosce gli elementi null e genera un'eccezione NullPointerException quando si tenta di aggiungere o ottenere tale elemento. Il metodo poll restituisce un elemento null se nessun elemento è stato inserito nella coda entro il timeout.

BlockingQueue<E> implementazioni

Diamo un'occhiata più da vicino a ciascuna delle nostre implementazioni di BlockingQueue :

ArrayBlockingQueue<E> è una classe di coda di blocco basata sul classico ring buffer. Qui abbiamo la possibilità di gestire l'“onestà” delle serrature. Se fair=false (impostazione predefinita), l'ordinamento dei thread non è garantito.

DelayQueue<E extends Delayed> è una classe che consente di estrarre elementi dalla coda solo dopo un certo ritardo, definito in ciascun elemento tramite il metodo getDelay dell'interfaccia Delayed .

LinkedBlockingQueue<E> è una coda di blocco sui nodi collegati, implementata sull'algoritmo "two lock queue": il primo blocco è per l'aggiunta, il secondo è per estrarre un elemento dalla coda. A causa dei blocchi, rispetto a ArrayBlockingQueue , questa classe ha prestazioni elevate, ma richiede più memoria. La dimensione della coda viene impostata tramite il costruttore ed è uguale a Integer.MAX_VALUE per impostazione predefinita.

PriorityBlockingQueue<E> è un wrapper multithread su PriorityQueue . Il comparatore è responsabile della logica con cui verrà aggiunto l'elemento. L'elemento più piccolo viene fuori per primo.

SynchronousQueue<E> - la coda funziona secondo il principio FIFO (first-in-first-out). Ogni operazione di inserimento blocca il thread "Producer" fino a quando il thread "Consumer" estrae l'elemento dalla coda e viceversa, il "Consumer" attenderà fino a quando il "Producer" inserisce l'elemento.

BlockingDeque<E> è un'interfaccia che descrive metodi aggiuntivi per una coda di blocco bidirezionale. I dati possono essere inseriti ed estratti da entrambi i lati della coda.

LinkedBlockingDeque<E> è una coda di blocco bidirezionale sui nodi collegati, implementata come un semplice elenco bidirezionale con un blocco. La dimensione della coda viene impostata tramite il costruttore ed è uguale a Integer.MAX_VALUE per impostazione predefinita.

TransferQueue<E> - l'interfaccia è interessante in quanto quando un elemento viene aggiunto alla coda, è possibile bloccare l'inserimento del thread Producer fino a quando un altro thread Consumer estrae l'elemento dalla coda. È inoltre possibile aggiungere un controllo per un timeout specifico o impostare un controllo per i consumatori in sospeso . Di conseguenza, otteniamo un meccanismo di trasferimento dati con supporto per messaggi asincroni e sincroni.

LinkedTransferQueue<E> è un'implementazione di TransferQueue basata sull'algoritmo Dual Queues con Slack. Fa un uso intenso di CAS (vedi sopra) e parcheggio thread quando è inattivo.