com.aol.cyclops.data.async

Class QueueFactories

java.lang.Object

com.aol.cyclops.data.async.QueueFactories

public class QueueFactories
extends java.lang.Object

Methods for generating QueueFactories for plumbing Streams together

  
    Queue<String> transferQueue = QueueFactories.<String>boundedQueue(4)
                                                 .build();
        
      new LazyReact(Executors.newFixedThreadPool(4)).generate(()->"data")
                                                      .map(d->"produced on " + Thread.currentThread().getId())
                                                      .peek(System.out::println)
                                                      .peek(d->transferQueue.offer(d))
                                                      .run();
        

       transferQueue.stream()
                    .map(e->"Consumed on " + Thread.currentThread().getId())
                     .futureOperations(Executors.newFixedThreadPool(1))
                     .forEach(System.out::println);
 
 
 
 

Constructor Summary

Constructors

Constructor and Description
QueueFactories()

Method Summary

Modifier and Type	Method and Description
static <T> QueueFactory<T>	boundedNonBlockingQueue(int queueSize) Creates an async.Queue backed by an Agrona ManyToOneConcurrentArrayQueue bounded by specified queueSize Wait strategy used is NoWaitRetry by default for both Consumers and Producers (both Consumers and Producers will repeatedly retry until successful).
static <T> QueueFactory<T>	boundedNonBlockingQueue(int queueSize, WaitStrategy<T> strategy) Generate QueueFactory for bounded non blocking queues.
static <T> QueueFactory<T>	boundedQueue(int queueSize) Create a QueueFactory for boundedQueues where bound is determined by the provided queueSize parameter Generated Queues will be backed by a LinkedBlockingQueue
static <T> QueueFactory<T>	singleWriterboundedNonBlockingQueue(int queueSize) Creates an async.Queue backed by an Agrona OneToOneConcurrentArrayQueue bounded by specified queueSize Wait strategy used is NoWaitRetry by default for both Consumers and Producers (both Consumers and Producers will repeatedly retry until successful).
static <T> QueueFactory<T>	singleWriterboundedNonBlockingQueue(int queueSize, WaitStrategy<T> strategy) Generate QueueFactory for bounded non blocking queues.
static <T> QueueFactory<T>	synchronousQueue()
static <T> QueueFactory<T>	unboundedNonBlockingQueue() Creates an async.Queue backed by a JDK Wait Free unbounded ConcurrentLinkedQueue Wait strategy used is NoWaitRetry by default for both Consumers and Producers (both Consumers and Producers will repeatedly retry until successful).
static <T> QueueFactory<T>	unboundedNonBlockingQueue(WaitStrategy<T> strategy) Creates an async.Queue backed by a JDK Wait Free unbounded ConcurrentLinkedQueue The provided WaitStrategy is used to determine behaviour of both producers and consumers when the Queue is full (producer) or empty (consumer).
static <T> QueueFactory<T>	unboundedQueue() ReactiveSeq.of(1,2,3) .flatMapPublisher(i->ReactiveSeq.range(i,1500),1000,QueueFactories.unboundedQueue()) .toListX()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

QueueFactories

public QueueFactories()

Method Detail

boundedQueue

public static <T> QueueFactory<T> boundedQueue(int queueSize)

Create a QueueFactory for boundedQueues where bound is determined by the provided queueSize parameter Generated Queues will be backed by a LinkedBlockingQueue

  
   Queue<String> transferQueue = QueueFactories.<String>boundedQueue(4)
                                                 .build();
        
         new LazyReact(Executors.newFixedThreadPool(4)).generate(()->"data")
                                                      .map(d->"produced on " + Thread.currentThread().getId())
                                                      .peek(System.out::println)
                                                      .peek(d->transferQueue.offer(d))
                                                      .run();
        

         transferQueue.stream()
                      .map(e->"Consumed on " + Thread.currentThread().getId())
                      .futureOperations(Executors.newFixedThreadPool(1))
                      .forEach(System.out::println);
 
 
 

Parameters:

queueSize - Max queue size

Returns:

QueueFactory for bounded Queues backed by a LinkedBlockingQueue

unboundedQueue

public static <T> QueueFactory<T> unboundedQueue()

  
   ReactiveSeq.of(1,2,3)
                    .flatMapPublisher(i->ReactiveSeq.range(i,1500),1000,QueueFactories.unboundedQueue())
                    .toListX()
 
 

Returns:

A QueueFactory for unbounded Queues backed by a LinkedBlockingQueue

unboundedNonBlockingQueue

public static <T> QueueFactory<T> unboundedNonBlockingQueue()

Creates an async.Queue backed by a JDK Wait Free unbounded ConcurrentLinkedQueue Wait strategy used is NoWaitRetry by default for both Consumers and Producers (both Consumers and Producers will repeatedly retry until successful). Use withConsumerWaitStrategy & withProducerWaitStrategy methods on the returned queue to change the wait strategy

 
    queue.withConsumerWaitStrategy(new DirectWaitStrategy())
         .withProducerWaitStrategy(new YieldWait());
 

Returns:

Factory for unbounded wait free queue backed by ConcurrentLinkedQueue

unboundedNonBlockingQueue

public static <T> QueueFactory<T> unboundedNonBlockingQueue(WaitStrategy<T> strategy)

Creates an async.Queue backed by a JDK Wait Free unbounded ConcurrentLinkedQueue The provided WaitStrategy is used to determine behaviour of both producers and consumers when the Queue is full (producer) or empty (consumer). , @see WaitStrategy#exponentialBackOff() , @see WaitStrategy#noWaitRetry()

Parameters:

strategy - Strategy to be employed by producers when Queue is full, or consumers when Queue is empty

Returns:

Factory for unbounded wait free queue backed by ConcurrentLinkedQueue

boundedNonBlockingQueue

public static <T> QueueFactory<T> boundedNonBlockingQueue(int queueSize)

Creates an async.Queue backed by an Agrona ManyToOneConcurrentArrayQueue bounded by specified queueSize Wait strategy used is NoWaitRetry by default for both Consumers and Producers (both Consumers and Producers will repeatedly retry until successful). Use withConsumerWaitStrategy & withProducerWaitStrategy methods on the returned queue to change the wait strategy

 
    queue.withConsumerWaitStrategy(new DirectWaitStrategy())
         .withProducerWaitStrategy(new YieldWait());
 

Parameters:

queueSize - upper bound for Queue

Returns:

bounded wait free Queue Factory backed by an Agrona ManyToOneConcurrentArrayQueue

boundedNonBlockingQueue

public static <T> QueueFactory<T> boundedNonBlockingQueue(int queueSize,
                                                          WaitStrategy<T> strategy)

Generate QueueFactory for bounded non blocking queues. Max queue size is determined by the input parameter. The provided WaitStrategy is used to determine behaviour of both producers and consumers when the Queue is full (producer) or empty (consumer). , @see WaitStrategy#exponentialBackOff() , @see WaitStrategy#noWaitRetry()

Parameters:

queueSize - Max Queue size

strategy - Strategy to be employed by producers when Queue is full, or consumers when Queue is empty

Returns:

bounded wait free Queue Factory backed by an Agrona ManyToOneConcurrentArrayQueue

singleWriterboundedNonBlockingQueue

public static <T> QueueFactory<T> singleWriterboundedNonBlockingQueue(int queueSize)

Creates an async.Queue backed by an Agrona OneToOneConcurrentArrayQueue bounded by specified queueSize Wait strategy used is NoWaitRetry by default for both Consumers and Producers (both Consumers and Producers will repeatedly retry until successful). Use withConsumerWaitStrategy & withProducerWaitStrategy methods on the returned queue to change the wait strategy

 
    queue.withConsumerWaitStrategy(new DirectWaitStrategy())
         .withProducerWaitStrategy(new YieldWait());
 

Parameters:

queueSize -

Returns:

singleWriterboundedNonBlockingQueue

public static <T> QueueFactory<T> singleWriterboundedNonBlockingQueue(int queueSize,
                                                                      WaitStrategy<T> strategy)

Generate QueueFactory for bounded non blocking queues. Max queue size is determined by the input parameter. The provided WaitStrategy is used to determine behaviour of both producers and consumers when the Queue is full (producer) or empty (consumer). , @see WaitStrategy#exponentialBackOff() , @see WaitStrategy#noWaitRetry()

Parameters:

queueSize - Max Queue size

strategy - Strategy to be employed by producers when Queue is full, or consumers when Queue is empty

Returns:

bounded wait free Queue Factory backed by an Agrona OneToOneConcurrentArrayQueue

synchronousQueue

public static <T> QueueFactory<T> synchronousQueue()

Returns:

async.Queue backed by a Synchronous Queue