How to use

Queue

in

java.util

/** Enqueues a event to be run. */
synchronized void add(ListenerCallQueue.Event<L> event, Object label) {
 waitQueue.add(event);
 labelQueue.add(label);
}

protected static Runnable pollTaskFrom(Queue<Runnable> taskQueue) {
  for (;;) {
    Runnable task = taskQueue.poll();
    if (task == WAKEUP_TASK) {
      continue;
    }
    return task;
  }
}

@Override
public boolean hasNext() {
 return !queue.isEmpty();
}

public void offer(T key) {
 if (keyPool.size() < MAX_SIZE) {
  keyPool.offer(key);
 }
}

static void clearQueue() {
 while (!QUEUE.isEmpty()) {
  QUEUE.remove();
 }
}

private void triggerActions(long targetTimeInNanoseconds) {
  for (;;) {
    TimedRunnable current = queue.peek();
    if (current == null || current.time > targetTimeInNanoseconds) {
      break;
    }
    // if scheduled time is 0 (immediate) use current virtual time
    time = current.time == 0 ? time : current.time;
    queue.remove(current);
    // Only execute if not unsubscribed
    if (!current.scheduler.disposed) {
      current.run.run();
    }
  }
  time = targetTimeInNanoseconds;
}

 public void testHoldsLockOnAllOperations() {
  create().element();
  create().offer("foo");
  create().peek();
  create().poll();
  create().remove();
  create().add("foo");
  create().addAll(ImmutableList.of("foo"));
  create().clear();
  create().contains("foo");
  create().containsAll(ImmutableList.of("foo"));
  create().equals(new ArrayDeque<>(ImmutableList.of("foo")));
  create().hashCode();
  create().isEmpty();
  create().iterator();
  create().remove("foo");
  create().removeAll(ImmutableList.of("foo"));
  create().retainAll(ImmutableList.of("foo"));
  create().size();
  create().toArray();
  create().toArray(new String[] {"foo"});
 }
}

public Object answer(InvocationOnMock invocation) throws Throwable {
  //see ThreadsShareGenerouslyStubbedMockTest
  Answer a;
  synchronized(answers) {
    a = answers.size() == 1 ? answers.peek() : answers.poll();
  }
  return a.answer(invocation);
}

 @Override
 public T next() {
  PeekingIterator<T> nextIter = queue.remove();
  T next = nextIter.next();
  if (nextIter.hasNext()) {
   queue.add(nextIter);
  }
  return next;
 }
}

  @Override
  public void run() {
    queue.remove(timedAction);
  }
}

private ByteBuffer assembleChunksAndReset() {
  ByteBuffer result;
  if (this.chunks.size() == 1) {
    result = this.chunks.remove();
  }
  else {
    result = ByteBuffer.allocate(getBufferSize());
    for (ByteBuffer partial : this.chunks) {
      result.put(partial);
    }
    result.flip();
  }
  this.chunks.clear();
  this.expectedContentLength = null;
  return result;
}

@Override
protected void flushCache() throws SockJsTransportFailureException {
  String[] messages = new String[getMessageCache().size()];
  for (int i = 0; i < messages.length; i++) {
    messages[i] = getMessageCache().poll();
  }
  SockJsMessageCodec messageCodec = getSockJsServiceConfig().getMessageCodec();
  SockJsFrame frame = SockJsFrame.messageFrame(messageCodec, messages);
  writeFrame(frame);
}

public void testConsumingIterable_queue_removesFromQueue() {
 Queue<Integer> queue = Lists.newLinkedList(asList(5, 14));
 Iterator<Integer> consumingIterator = Iterables.consumingIterable(queue).iterator();
 assertEquals(5, queue.peek().intValue());
 assertEquals(5, consumingIterator.next().intValue());
 assertEquals(14, queue.peek().intValue());
 assertTrue(consumingIterator.hasNext());
 assertTrue(queue.isEmpty());
}

/**
 * Return the number of tasks that are pending for processing.
 *
 * <strong>Be aware that this operation may be expensive as it depends on the internal implementation of the
 * SingleThreadEventExecutor. So use it with care!</strong>
 */
public int pendingTasks() {
  return taskQueue.size();
}

  @Override
  public void accept(GroupedUnicast<K, V> value) {
    evictedGroups.offer(value);
  }
}

final ScheduledFutureTask<?> peekScheduledTask() {
  Queue<ScheduledFutureTask<?>> scheduledTaskQueue = this.scheduledTaskQueue;
  if (scheduledTaskQueue == null) {
    return null;
  }
  return scheduledTaskQueue.peek();
}

public synchronized List<PrioritizedSplitRunner> destroy()
{
  destroyed = true;
  ImmutableList.Builder<PrioritizedSplitRunner> builder = ImmutableList.builder();
  builder.addAll(runningIntermediateSplits);
  builder.addAll(runningLeafSplits);
  builder.addAll(queuedLeafSplits);
  runningIntermediateSplits.clear();
  runningLeafSplits.clear();
  queuedLeafSplits.clear();
  return builder.build();
}

@Override
public E remove() {
 synchronized (mutex) {
  return delegate().remove();
 }
}

 @Override
 public T computeNext() {
  return queue.isEmpty() ? endOfData() : queue.remove();
 }
}

/** Lookups on the map view shouldn't impact the recency queue. */
public void testAsMapRecency() {
 CacheBuilder<Object, Object> builder =
   createCacheBuilder().concurrencyLevel(1).maximumSize(SMALL_MAX_SIZE);
 LocalLoadingCache<Object, Object> cache = makeCache(builder, identityLoader());
 Segment<Object, Object> segment = cache.localCache.segments[0];
 ConcurrentMap<Object, Object> map = cache.asMap();
 Object one = new Object();
 assertSame(one, cache.getUnchecked(one));
 assertTrue(segment.recencyQueue.isEmpty());
 assertSame(one, map.get(one));
 assertSame(one, segment.recencyQueue.peek().getKey());
 assertSame(one, cache.getUnchecked(one));
 assertFalse(segment.recencyQueue.isEmpty());
}