How to use

ConcurrentQueueSpec

in

org.jctools.queues.spec

public static ConcurrentQueueSpec createBoundedMpmc(int capacity)
{
  return new ConcurrentQueueSpec(0, 0, capacity, Ordering.FIFO, Preference.NONE);
}

public static <E> Queue<E> newQueue(ConcurrentQueueSpec qs)
  if (qs.isBounded())
    if (qs.isSpsc())
    else if (qs.isMpsc())
    else if (qs.isSpmc())
    if (qs.isSpsc())
    else if (qs.isMpsc())

public static <E> ConcurrentQueue<E> newQueue(ConcurrentQueueSpec qs) {
  if (qs.isBounded()) {
    // SPSC
    if (qs.consumers == 1 && qs.producers == 1) {
      return new SpscArrayConcurrentQueue<E>(qs.capacity);
    }
    else {
      return new MpmcArrayConcurrentQueue<E>(qs.capacity);
    }
  }
  return new GenericQueue<E>();
}

  return new SpscArrayQueue<T>(queueCapacity);
case 308:
  return BlockingQueueFactory.newBlockingQueue(ConcurrentQueueSpec.createBoundedSpsc(queueCapacity));
case 31:
  return new SpscLinkedQueue<T>();
  return new SpmcArrayQueue<T>(queueCapacity);
case 508:
  return BlockingQueueFactory.newBlockingQueue(ConcurrentQueueSpec.createBoundedSpmc(queueCapacity));
case 6:
  return new MpscArrayQueue<T>(queueCapacity);
case 608:
  return BlockingQueueFactory.newBlockingQueue(ConcurrentQueueSpec.createBoundedMpsc(queueCapacity));
case 61:
  return new MpscCompoundQueue<T>(queueCapacity);
  return new MpmcArrayQueue<T>(queueCapacity);
  case 708:
    return BlockingQueueFactory.newBlockingQueue(ConcurrentQueueSpec.createBoundedMpmc(queueCapacity));
case 71:
  return new MpmcConcurrentQueueStateMarkers<T>(queueCapacity);

if (!spec.isMpmc())

int maxPooledElements = configurationRegistry.getConfig(ReporterConfiguration.class).getMaxQueueSize() * 2;
coreConfiguration = configurationRegistry.getConfig(CoreConfiguration.class);
transactionPool = QueueBasedObjectPool.ofRecyclable(AtomicQueueFactory.<Transaction>newQueue(createBoundedMpmc(maxPooledElements)), false,
  new Allocator<Transaction>() {
    @Override
spanPool = QueueBasedObjectPool.ofRecyclable(AtomicQueueFactory.<Span>newQueue(createBoundedMpmc(maxPooledElements)), false,
  new Allocator<Span>() {
    @Override
errorPool = QueueBasedObjectPool.ofRecyclable(AtomicQueueFactory.<ErrorCapture>newQueue(createBoundedMpmc(maxPooledElements / 2)), false,
  new Allocator<ErrorCapture>() {
    @Override
runnableSpanWrapperObjectPool = QueueBasedObjectPool.ofRecyclable(AtomicQueueFactory.<SpanInScopeRunnableWrapper>newQueue(createBoundedMpmc(MAX_POOLED_RUNNABLES)), false,
  new Allocator<SpanInScopeRunnableWrapper>() {
    @Override
runnableContextWrapperObjectPool = QueueBasedObjectPool.ofRecyclable(AtomicQueueFactory.<ContextInScopeRunnableWrapper>newQueue(createBoundedMpmc(MAX_POOLED_RUNNABLES)), false,
  new Allocator<ContextInScopeRunnableWrapper>() {
    @Override
callableContextWrapperObjectPool = QueueBasedObjectPool.ofRecyclable(AtomicQueueFactory.<ContextInScopeCallableWrapper<?>>newQueue(createBoundedMpmc(MAX_POOLED_RUNNABLES)), false,
  new Allocator<ContextInScopeCallableWrapper<?>>() {
    @Override

@Test
public void testPowerOf2Capacity() {
 assumeThat(spec.isBounded(), is(true));
 int n = Pow2.roundToPowerOfTwo(spec.capacity);
 for (int i = 0; i < n; i++) {
  assertTrue("Failed to insert:" + i, queue.offer(i));
 }
 assertFalse(queue.offer(n));
}

if (!spec.isMpmc())

public static <E> Queue<E> newQueue(ConcurrentQueueSpec qs)
  if (qs.isBounded())
    if (qs.isSpsc())
    else if (qs.isMpsc())
    else if (qs.isSpmc())
    if (qs.isSpsc())
    else if (qs.isMpsc())

public static ConcurrentQueueSpec createBoundedSpsc(int capacity)
{
  return new ConcurrentQueueSpec(1, 1, capacity, Ordering.FIFO, Preference.NONE);
}

@Test
public void testPowerOf2Capacity()
{
  assumeThat(spec.isBounded(), is(true));
  int n = Pow2.roundToPowerOfTwo(spec.capacity);
  for (int i = 0; i < n; i++)
  {
    assertTrue("Failed to insert:" + i, queue.offer(i));
  }
  assertFalse(queue.offer(n));
}

if (qs.isBounded()) {
  if (qs.isSpsc()) {
    return getBlockingQueueFrom(SpscArrayQueue.class, takeStratClass, putStratClass, qs.capacity);
  else if (qs.isMpsc()) {
    if (qs.ordering != Ordering.NONE) {
      return getBlockingQueueFrom(MpscArrayQueue.class, takeStratClass, putStratClass,
  else if (qs.isSpmc()) {
    return getBlockingQueueFrom(SpmcArrayQueue.class, takeStratClass, putStratClass, qs.capacity);
  else if (qs.isMpmc()) {
    return getBlockingQueueFrom(MpmcArrayQueue.class, takeStratClass, putStratClass, qs.capacity);
} else {
  if (qs.isSpsc()) {
    return getBlockingQueueFrom(SpscLinkedQueue.class, takeStratClass, putStratClass, -1);
  else if (qs.isMpsc()) {
    if (UnsafeAccess.SUPPORTS_GET_AND_SET) {
      return getBlockingQueueFrom(MpscLinkedQueue8.class, takeStratClass, putStratClass, -1);

public static ConcurrentQueueSpec createBoundedMpsc(int capacity)
{
  return new ConcurrentQueueSpec(0, 1, capacity, Ordering.FIFO, Preference.NONE);
}

@Test
public void testPowerOf2Capacity()
{
  assumeThat(spec.isBounded(), is(true));
  int n = Pow2.roundToPowerOfTwo(spec.capacity);
  for (int i = 0; i < n; i++)
  {
    assertTrue("Failed to insert:" + i, queue.relaxedOffer(i));
  }
  assertFalse(queue.relaxedOffer(n));
}

public static <E> Queue<E> newQueue(ConcurrentQueueSpec qs)
  if (qs.isBounded())
    if (qs.isSpsc())
    else if (qs.isMpsc())
    else if (qs.isSpmc())
    if (qs.isSpsc())
    else if (qs.isMpsc())

public static ConcurrentQueueSpec createBoundedSpmc(int capacity)
{
  return new ConcurrentQueueSpec(1, 0, capacity, Ordering.FIFO, Preference.NONE);
}

@Test
public void supplyMessageUntilFull()
{
  assumeThat(spec.isBounded(), is(Boolean.TRUE));
  final Val instances = new Val();
  instances.value = 0;
  final MessagePassingQueue.Supplier<Integer> messageFactory = () -> instances.value++;
  final int capacity = queue.capacity();
  int filled = 0;
  while (filled < capacity)
  {
    filled += queue.fill(messageFactory, capacity - filled);
  }
  assertEquals(instances.value, capacity);
  final int noItems = queue.fill(messageFactory, 1);
  assertEquals(noItems, 0);
  assertEquals(instances.value, capacity);
}

public static <E> Queue<E> newQueue(ConcurrentQueueSpec qs)
  if (qs.isBounded())
    if (qs.isSpsc())
    else if (qs.isMpsc())
    else if (qs.isSpmc())
    if (qs.isSpsc())
    else if (qs.isMpsc())

public static Object[] makeQueue(int producers, int consumers, int capacity, Ordering ordering,
  Queue<Integer> q) {
 ConcurrentQueueSpec spec =
   new ConcurrentQueueSpec(producers, consumers, capacity, ordering, Preference.NONE);
 if (q == null) {
  q = QueueFactory.newQueue(spec);
 }
 return new Object[] {spec, q};
}

@Test
public void testSizeIsTheNumberOfOffers()
{
  int currentSize = 0;
  while (currentSize < SIZE && queue.relaxedOffer(currentSize))
  {
    currentSize++;
    assertFalse(queue.isEmpty());
    assertTrue(queue.size() == currentSize);
  }
  if (spec.isBounded())
  {
    assertEquals(spec.capacity, currentSize);
  }
  else
  {
    assertEquals(SIZE, currentSize);
  }
}