QueueFactories (cyclops-react 2.0.0-MI1 API)

java.lang.Object
- cyclops.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()

Constructors
Constructor and Description
`QueueFactories()`

Method Summary

All Methods Static Methods Concrete Methods
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) .flatMapP(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)
                    .flatMapP(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

Class QueueFactories

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

QueueFactories

Method Detail

boundedQueue

unboundedQueue

unboundedNonBlockingQueue

unboundedNonBlockingQueue

boundedNonBlockingQueue

boundedNonBlockingQueue

singleWriterboundedNonBlockingQueue

singleWriterboundedNonBlockingQueue

synchronousQueue