Example usage for java.util.concurrent BlockingQueue interface-usage

Introduction

In this page you can find the example usage for java.util.concurrent BlockingQueue interface-usage.

Usage

From source file io.kahu.hawaii.util.call.dispatch.HawaiiBlockingQueue.java

@ThreadSafe
public class HawaiiBlockingQueue<E> implements BlockingQueue<E> {
    private final BlockingQueue<E> delegate;

    public HawaiiBlockingQueue(BlockingQueue<E> delegate) {
        this.delegate = delegate;

From source file org.polymap.core.runtime.MapBlockingQueue.java

/**
 * EXPERIMENTAL test code to implement a {@link BlockingQueue} based on a
 * {@link ConcurrentMap}.
 * 
 * @author <a href="http://www.polymap.de">Falko Brutigam</a>
 */

From source file org.apache.hadoop.hbase.thrift.CallQueue.java

/**
 * A BlockingQueue reports waiting time in queue and queue length to
 * ThriftMetrics.
 */
@InterfaceAudience.Private
public class CallQueue implements BlockingQueue<Runnable> {

From source file org.springframework.integration.store.MessageGroupQueue.java

/**
 * A {@link BlockingQueue} that is backed by a {@link MessageGroupStore}. Can be used to ensure guaranteed delivery in
 * the face of transaction rollback (assuming the store is transactional) and also to ensure messages are not lost if
 * the process dies (assuming the store is durable). To use the queue across process re-starts, the same group id
 * must be provided, so it needs to be unique but identifiable with a single logical instance of the queue.
 *

From source file org.apache.hadoop.hbase.regionserver.PriorityCompactionQueue.java

/**
 * This class delegates to the BlockingQueue but wraps all HRegions in
 * compaction requests that hold the priority and the date requested.
 *
 * Implementation Note: With an elevation time of -1 there is the potential for
 * starvation of the lower priority compaction requests as long as there is a

From source file org.apache.hadoop.hbase.util.BoundedPriorityBlockingQueue.java

/**
 * A generic bounded blocking Priority-Queue.
 *
 * The elements of the priority queue are ordered according to the Comparator
 * provided at queue construction time.
 *

From source file org.apache.hadoop.ipc.FairCallQueue.java

/**
 * A queue with multiple levels for each priority.
 */
public class FairCallQueue<E extends Schedulable> extends AbstractQueue<E> implements BlockingQueue<E> {
    @Deprecated
    public static final int IPC_CALLQUEUE_PRIORITY_LEVELS_DEFAULT = 4;

From source file org.apache.streams.local.queues.ThroughputQueue.java

/**
 * A {@link java.util.concurrent.BlockingQueue} implementation that allows the measure measurement of how
 * data flows through the queue.  Is also a {@code MBean} so the flow statistics can be viewed through
 * JMX. Registration of the bean happens whenever a constructor receives a non-null id.
 * <p/>
 * !!! Warning !!!

From source file LinkedTransferQueue.java

/**
 * An unbounded <tt>TransferQueue</tt> based on linked nodes.
 * This queue orders elements FIFO (first-in-first-out) with respect
 * to any given producer.  The <em>head</em> of the queue is that
 * element that has been on the queue the longest time for some
 * producer.  The <em>tail</em> of the queue is that element that has