congrats Icon
New! Tabnine Pro 14-day free trial
Start a free trial
Tabnine Logo
ConcurrentQueueSpec
Code IndexAdd Tabnine to your IDE (free)

How to use
ConcurrentQueueSpec
in
org.jctools.queues.spec

Best Java code snippets using org.jctools.queues.spec.ConcurrentQueueSpec (Showing top 20 results out of 315)

origin: JCTools/JCTools

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

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())
origin: JCTools/JCTools

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>();
}
origin: JCTools/JCTools

  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);
origin: JCTools/JCTools

if (!spec.isMpmc())
origin: elastic/apm-agent-java

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
origin: ben-manes/caffeine

@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));
}
origin: JCTools/JCTools

if (!spec.isMpmc())
origin: JCTools/JCTools

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())
origin: JCTools/JCTools

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

@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));
}
origin: JCTools/JCTools

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);
origin: JCTools/JCTools

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

@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));
}
origin: org.jctools/jctools-core

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())
origin: JCTools/JCTools

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

@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);
}
origin: org.jctools/jctools-core

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())
origin: ben-manes/caffeine

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};
}
origin: JCTools/JCTools

@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);
  }
}
org.jctools.queues.specConcurrentQueueSpec

Most used methods

  • <init>
  • isBounded
  • createBoundedMpmc
  • isMpmc
  • isMpsc
  • isSpmc
  • isSpsc
  • createBoundedMpsc
  • createBoundedSpmc
  • createBoundedSpsc

Popular in Java

  • Start an intent from android
  • orElseThrow (Optional)
    Return the contained value, if present, otherwise throw an exception to be created by the provided s
  • setContentView (Activity)
  • runOnUiThread (Activity)
  • Runnable (java.lang)
    Represents a command that can be executed. Often used to run code in a different Thread.
  • SimpleDateFormat (java.text)
    Formats and parses dates in a locale-sensitive manner. Formatting turns a Date into a String, and pa
  • ConcurrentHashMap (java.util.concurrent)
    A plug-in replacement for JDK1.5 java.util.concurrent.ConcurrentHashMap. This version is based on or
  • ImageIO (javax.imageio)
  • JComboBox (javax.swing)
  • BasicDataSource (org.apache.commons.dbcp)
    Basic implementation of javax.sql.DataSource that is configured via JavaBeans properties. This is no
  • Top plugins for WebStorm
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimAtomGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyStudentsTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now