Examples of BlockingQueue

edu.emory.mathcs.backport.java.util.concurrent.BlockingQueue

A {@link edu.emory.mathcs.backport.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.

BlockingQueue methods come in four forms, with different ways of 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 null or 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:

	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 BlockingQueue does not accept null elements. Implementations throw NullPointerException on attempts to add, put or offer a null. A null is used as a sentinel value to indicate failure of poll operations.

A BlockingQueue may be capacity bounded. At any given time it may have a remainingCapacity beyond which no additional elements can be put without blocking. A BlockingQueue without any intrinsic capacity constraints always reports a remaining capacity of Integer.MAX_VALUE.

BlockingQueue implementations are designed to be used primarily 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 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.

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

A BlockingQueue does not intrinsically support any 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 BlockingQueue can safely be used with multiple producers and multiple consumers.

 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(); } }

This interface is a member of the Java Collections Framework. @since 1.5 @author Doug Lea

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

jmt.engine.NodeSections.BlockingQueue
This class implements the queue of a region input station, that is the node which controls the access to a blocking region. @author Stefano OminiModifief by Bertoli Marco 31-03-2006 (my birthday!!!) Modified by Ashanka (Oct 2009): Desc: FCR(Finite Capacity Region) is a blocking region and it was measuring wrong values for the Performance Indices. This was because the Jobs in FCR were not considering the time spent in the Queuing Stations in the FCR and simply reporting time spent in Queuing in FCR. This behavior is incorrect as Performance Indices for FCR should also contain the time spent in the FCR and not only the time spent queuing. Approach taken presently to rectify is to delay the capture of the performance indices untill the job is out of the FCR. So the job dropping are manually handled for Blocking region at Node level.
org.apache.maven.plugin.surefire.util.internal.BlockingQueue
A very simple blocking queue that might have stricter constraints than the standard jdk1.5 blockingqueues. @author Kristian Rosenvold
org.apache.mina.util.BlockingQueue
A synchronized version of {@link Queue}. @author The Apache Directory Project (dev@directory.apache.org) @version $Rev: 357871 $, $Date: 2005-12-20 10:56:40 +0900 (Tue, 20 Dec 2005) $
org.mom4j.xcp.util.BlockingQueue

Examples of java.util.concurrent.BlockingQueue

        }
        super.doStop();
    }


    public void run() {
        final BlockingQueue queue = endpoint.getQueue();


        while (queue != null && isRunAllowed()) {
            final Exchange exchange = new DefaultExchange(this.getEndpoint().getCamelContext());


            try {
                final Object body = queue.poll(endpoint.getConfiguration().getPollInterval(), TimeUnit.MILLISECONDS);


                if (body != null) {
                    exchange.getIn().setBody(body);
                    try {
                        processor.process(exchange, new AsyncCallback() {

View Full Code Here

Examples of java.util.concurrent.BlockingQueue

    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

Examples of java.util.concurrent.BlockingQueue

      logger.info("Initializing ThreadPoolExecutor" + (this.beanName != null ? " '" + this.beanName + "'" : ""));
    }
    if (!this.threadNamePrefixSet && this.beanName != null) {
      setThreadNamePrefix(this.beanName + "-");
    }
    BlockingQueue queue = createQueue(this.queueCapacity);
    this.threadPoolExecutor = new ThreadPoolExecutor(
        this.corePoolSize, this.maxPoolSize, this.keepAliveSeconds, TimeUnit.SECONDS,
        queue, this.threadFactory, this.rejectedExecutionHandler);
    if (this.allowCoreThreadTimeOut) {
      this.threadPoolExecutor.allowCoreThreadTimeOut(true);

View Full Code Here

Examples of java.util.concurrent.BlockingQueue

   */
  public void initialize() {
    if (logger.isInfoEnabled()) {
      logger.info("Initializing ThreadPoolExecutor" + (this.beanName != null ? " '" + this.beanName + "'" : ""));
    }
    BlockingQueue queue = createQueue(this.queueCapacity);
    this.threadPoolExecutor = new ThreadPoolExecutor(
        this.corePoolSize, this.maxPoolSize, this.keepAliveSeconds, TimeUnit.SECONDS,
        queue, this.threadFactory, this.rejectedExecutionHandler);
  }

View Full Code Here

Examples of java.util.concurrent.BlockingQueue

        }
        super.doStop();
    }


    public void run() {
        final BlockingQueue queue = endpoint.getQueue();


        while (queue != null && isRunAllowed()) {
            final Exchange exchange = new DefaultExchange(this.getEndpoint().getCamelContext());


            try {
                final Object body = queue.poll(endpoint.getConfiguration().getPollInterval(), TimeUnit.MILLISECONDS);


                if (body != null) {
                    if (body instanceof DefaultExchangeHolder) {
                        DefaultExchangeHolder.unmarshal(exchange, (DefaultExchangeHolder) body);
                    } else {

View Full Code Here

Examples of java.util.concurrent.BlockingQueue

    /**
     * iterator ordering is FIFO
     */
    @Test
    public void testIteratorOrdering() {
        final BlockingQueue q = new LocalConcurrentBlockingObjectQueue(3);
        q.add(one);
        q.add(two);
        q.add(three);


        assertEquals("queue should be full", 0, q.remainingCapacity());


        int k = 0;
        for (Iterator it = q.iterator(); it.hasNext(); ) {
            assertEquals(++k, it.next());
        }
        assertEquals(3, k);
    }

View Full Code Here

Examples of java.util.concurrent.BlockingQueue

    /**
     * Modifications do not cause iterators to fail
     */
    @Test
    public void testWeaklyConsistentIteration() {
        final BlockingQueue q = new LocalConcurrentBlockingObjectQueue(3);
        q.add(one);
        q.add(two);
        q.add(three);
        for (Iterator it = q.iterator(); it.hasNext(); ) {
            q.remove();
            it.next();
        }
        assertEquals(0, q.size());
    }

View Full Code Here

Examples of java.util.concurrent.BlockingQueue

    /**
     * toString contains toStrings of elements
     */
    @Test
    public void testToString() {
        BlockingQueue q = populatedQueue(SIZE);
        String s = q.toString();
        for (int i = 0; i < SIZE; ++i) {
            assertTrue(s.contains(String.valueOf(i)));
        }
    }

View Full Code Here

Examples of java.util.concurrent.BlockingQueue

    /**
     * offer transfers elements across Executor tasks
     */
    @Test
    public void testOfferInExecutor() {
        final BlockingQueue q = new LocalConcurrentBlockingObjectQueue(2);
        q.add(one);
        q.add(two);
        ExecutorService executor = Executors.newFixedThreadPool(2);
        final CheckedBarrier threadsStarted = new CheckedBarrier(2);
        executor.execute(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                assertFalse(q.offer(three));
                threadsStarted.await();
                assertTrue(q.offer(three, LONG_DELAY_MS, MILLISECONDS));
                assertEquals(0, q.remainingCapacity());
            }
        });


        executor.execute(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                threadsStarted.await();
                assertEquals(0, q.remainingCapacity());
                assertSame(one, q.take());
            }
        });


        joinPool(executor);
    }

View Full Code Here

Examples of java.util.concurrent.BlockingQueue

    /**
     * timed poll retrieves elements across Executor threads
     */
    @Test
    public void testPollInExecutor() {
        final BlockingQueue q = new LocalConcurrentBlockingObjectQueue(2);
        final CheckedBarrier threadsStarted = new CheckedBarrier(2);
        ExecutorService executor = Executors.newFixedThreadPool(2);
        executor.execute(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                assertNull(q.poll());
                threadsStarted.await();
                assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
                checkEmpty(q);
            }
        });


        executor.execute(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                threadsStarted.await();
                q.put(one);
            }
        });


        joinPool(executor);
    }

View Full Code Here

0 1 2 3 4 5

TOP

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.