Examples of java.util.concurrent.BlockingQueue

java.util.concurrent.BlockingQueue

A {@link java.util.Queue} that additionally supports operationsthat wait for the queue to become non-empty when retrieving an element, and wait for space to become available in the queue when storing an element.

{@code BlockingQueue} methods come in four forms, with different waysof handling operations that cannot be satisfied immediately, but may be satisfied at some point in the future: one throws an exception, the second returns a special value (either {@code null} or {@code false}, depending on the operation), the third blocks the current thread indefinitely until the operation can succeed, and the fourth blocks for only a given maximum time limit before giving up. These methods are summarized in the following table:

Summary of BlockingQueue methods
	Throws exception	Special value	Blocks	Times out
Insert	{@link #add add(e)}	{@link #offer offer(e)}	{@link #put put(e)}	{@link #offer(Object,long,TimeUnit) offer(e, time, unit)}
Remove	{@link #remove remove()}	{@link #poll poll()}	{@link #take take()}	{@link #poll(long,TimeUnit) poll(time, unit)}
Examine	{@link #element element()}	{@link #peek peek()}	not applicable	not applicable

A {@code BlockingQueue} does not accept {@code null} elements.Implementations throw {@code NullPointerException} on attemptsto {@code add}, {@code put} or {@code offer} a {@code null}. A {@code null} is used as a sentinel value to indicate failure of{@code poll} operations.

A {@code BlockingQueue} may be capacity bounded. At any giventime it may have a {@code remainingCapacity} beyond which noadditional elements can be {@code put} without blocking.A {@code BlockingQueue} without any intrinsic capacity constraints alwaysreports a remaining capacity of {@code Integer.MAX_VALUE}.

{@code BlockingQueue} implementations are designed to be usedprimarily for producer-consumer queues, but additionally support the {@link java.util.Collection} interface. So, for example, it ispossible to remove an arbitrary element from a queue using {@code remove(x)}. However, such operations are in general not performed very efficiently, and are intended for only occasional use, such as when a queued message is cancelled.

{@code BlockingQueue} implementations are thread-safe. Allqueuing methods achieve their effects atomically using internal locks or other forms of concurrency control. However, the bulk Collection operations {@code addAll}, {@code containsAll}, {@code retainAll} and {@code removeAll} arenot necessarily performed atomically unless specified otherwise in an implementation. So it is possible, for example, for {@code addAll(c)} to fail (throwing an exception) after addingonly some of the elements in {@code c}.

A {@code BlockingQueue} does not intrinsically supportany kind of "close" or "shutdown" operation to indicate that no more items will be added. The needs and usage of such features tend to be implementation-dependent. For example, a common tactic is for producers to insert special end-of-stream or poison objects, that are interpreted accordingly when taken by consumers.

Usage example, based on a typical producer-consumer scenario. Note that a {@code BlockingQueue} can safely be used with multipleproducers and multiple consumers.

  {@code}class Producer implements Runnable  private final BlockingQueue queue; Producer(BlockingQueue q) { queue = q; } public void run() { try { while (true) { queue.put(produce()); } } catch (InterruptedException ex) { ... handle ...} } Object produce() { ... } } class Consumer implements Runnable { private final BlockingQueue queue; Consumer(BlockingQueue q) { queue = q; } public void run() { try { while (true) { consume(queue.take()); } } catch (InterruptedException ex) { ... handle ...} } void consume(Object x) { ... } } class Setup { void main() { BlockingQueue q = new SomeQueueImplementation(); Producer p = new Producer(q); Consumer c1 = new Consumer(q); Consumer c2 = new Consumer(q); new Thread(p).start(); new Thread(c1).start(); new Thread(c2).start(); } }}

Memory consistency effects: As with other concurrent collections, actions in a thread prior to placing an object into a {@code BlockingQueue}happen-before actions subsequent to the access or removal of that element from the {@code BlockingQueue} in another thread.

This interface is a member of the Java Collections Framework. @since 1.5 @author Doug Lea @param < E> the type of elements held in this collection

        Object eventThread = field.get(zkclient);
        // System.out.println("field: " + eventThread);


        java.lang.reflect.Field field2 = getField(eventThread.getClass(), "_events");
        field2.setAccessible(true);
        BlockingQueue queue = (BlockingQueue) field2.get(eventThread);
        // System.out.println("field2: " + queue + ", " + queue.size());




        if (queue == null) {
            LOG.error("fail to get event-queue from zkclient. skip waiting");
            return false;
        }


        for (int i = 0; i < 20; i++) {
            if (queue.size() == 0) {
                return true;
            }
            Thread.sleep(100);
            System.out.println("pending zk-events in queue: " + queue);
        }

View Full Code Here

      if (!started) {
         throw new IllegalStateException("You have to start the service first!");
      }
      if (address == null)
         throw new NullPointerException("Null address not supported!");
      BlockingQueue queue = address2key.get(address);
      if (queue == null)
         throw new IllegalStateException("Address " + address + " is no longer in the cluster");


      try {
         Object result = null;
         while (result == null && !keyGenWorker.isStopped()) {
            // obtain the read lock inside the loop, otherwise a topology change will never be able
            // to obtain the write lock
            maxNumberInvariant.readLock().lock();
            try {
               // first try to take an element without waiting
               result = queue.poll();
               if (result == null) {
                  // there are no elements in the queue, make sure the producer is started
                  keyProducerStartLatch.open();
                  // our address might have been removed from the consistent hash
                  if (!isNodeInConsistentHash(address))
                     throw new IllegalStateException("Address " + address + " is no longer in the cluster");
               }
            } finally {
               maxNumberInvariant.readLock().unlock();
            }
         }
         exitingNumberOfKeys.decrementAndGet();
         return result;
      } finally {
         if (queue.size() < bufferSize * THRESHOLD + 1) {
            keyProducerStartLatch.open();
         }
      }
   }

View Full Code Here

         }
         return false;
      }


      private boolean tryAddKey(Address address, Object key) {
         BlockingQueue queue = address2key.get(address);
         // on node stop the distribution manager might still return the dead server for a while after we have already removed its queue
         if (queue == null)
            return false;


         boolean added = queue.offer(key);
         if (added) {
            exitingNumberOfKeys.incrementAndGet();
         }
         if (log.isTraceEnabled()) {
            if (added)

View Full Code Here

    private void execute(Object task, int partitionId, boolean priority) {
        if (task == null) {
            throw new NullPointerException();
        }


        BlockingQueue workQueue;
        Queue priorityWorkQueue;
        if (partitionId < 0) {
            workQueue = genericWorkQueue;
            priorityWorkQueue = genericPriorityWorkQueue;
        } else {

View Full Code Here

      if (!started) {
         throw new IllegalStateException("You have to start the service first!");
      }
      if (address == null)
         throw new NullPointerException("Null address not supported!");
      BlockingQueue queue = address2key.get(address);
      if (queue == null)
         return null; // No address for key, unlikely


      try {
         maxNumberInvariant.readLock().lock();
         Object result;
         try {
            result = queue.take();
         } finally {
            maxNumberInvariant.readLock().unlock();
         }
         exitingNumberOfKeys.decrementAndGet();
         return result;
      } catch (InterruptedException e) {
         Thread.currentThread().interrupt();
         return null;
      } finally {
         if (queue.size() < maxNumberOfKeys.get() * THRESHOLD + 1) {
            keyProducerStartLatch.open();
         }
      }
   }

View Full Code Here

         }
         return false;
      }


      private void tryAddKey(Address address, Object key) {
         BlockingQueue queue = address2key.get(address);
         // on node stop the distribution manager might still return the dead server for a while after we have already removed its queue
         if (queue == null)
            return;


         boolean added = queue.offer(key);
         if (added) {
            exitingNumberOfKeys.incrementAndGet();
         }
         if (log.isTraceEnabled()) {
            if (added)

View Full Code Here

         }
         return false;
      }


      private void tryAddKey(Address address, Object key) {
         BlockingQueue queue = address2key.get(address);
         boolean added = queue.offer(key);
         if (added) {
            exitingNumberOfKeys.incrementAndGet();
         }
         if (log.isTraceEnabled()) {
            if (added)

View Full Code Here

      if (!started) {
         throw new IllegalStateException("You have to start the service first!");
      }
      if (address == null)
         throw new NullPointerException("Null address not supported!");
      BlockingQueue queue = address2key.get(address);
      try {
         maxNumberInvariant.readLock().lock();
         Object result;
         try {
            result = queue.take();
         } finally {
            maxNumberInvariant.readLock().unlock();
         }
         exitingNumberOfKeys.decrementAndGet();
         return result;
      } catch (InterruptedException e) {
         Thread.currentThread().interrupt();
         return null;
      } finally {
         if (queue.size() < maxNumberOfKeys.get() * THRESHOLD + 1) {
            keyProducerStartLatch.open();
         }
      }
   }

View Full Code Here

     * @param batchSize the number of elements to feed at once into main output
     * queue.
     * @return the newly registered queue
     */
    public BlockingQueue<JTweet> register(String queueName, int capacity, int batchSize) {
        BlockingQueue q = new LinkedBlockingQueue<JTweet>(capacity);
        QueueInfo qInfo = new QueueInfo(queueName, q);
        for (QueueInfo<JTweet> qi : inputQueues) {
            if (qi.getName().equals(queueName))
                throw new IllegalStateException("cannot register queue. Queue " + queueName + " already exists");
        }

View Full Code Here


        val = ejbContainer.getPropertyValue(RuntimeTagNames.PRESTART_ALL_CORE_THREADS);
        boolean preStartAllCoreThreads = val != null ? Boolean.parseBoolean(val.trim())
                : EjbContainer.DEFAULT_PRESTART_ALL_CORE_THREADS;


        BlockingQueue workQueue = queueCapacity > 0
                ? new LinkedBlockingQueue<Runnable>(queueCapacity)
                : new SynchronousQueue(true);


        result = new EjbThreadPoolExecutor(corePoolSize, maxPoolSize, keepAliveSeconds, workQueue, poolName);

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of java.util.concurrent.BlockingQueue

collections.queue.arrayBlockingQueue.ArrayBlockingQueueUsing

com.alibaba.asyncload.AsyncLoadExecutor

com.hazelcast.executor.ExecutorServiceTest

com.hazelcast.spi.impl.BasicOperationScheduler

com.intellij.util.ui.UIUtil

com.netflix.eventbus.spi.CatchAllSubscriber

com.sun.ejb.containers.EjbContainerUtilImpl

de.jetwick.tw.TweetConsumer

io.druid.client.cache.BytesBoundedLinkedQueueTest

net.openhft.chronicle.sandbox.queue.common.BlockingQueueTest

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.