Circular frame queue for a link, transport, application or user layer frame management, with 2 pointers
Implementations of this interface must be threadsafe.
Queues are transactional. If a datastore transaction is in progress when {@link #add()} or {@link #add(TaskOptions)} is invoked, the task will onlybe added to the queue if the datastore transaction successfully commits. If you want to add a task to a queue and have that operation succeed or fail independently of an existing datastore transaction you can invoke {@link #add(Transaction,TaskOptions)} with a {@code null} transactionargument. Note that while the addition of the task to the queue can participate in an existing transaction, the execution of the task cannot participate in this transaction. In other words, when the transaction commits you are guaranteed that your task will be added and run, not that your task executed successfully.
Queues may be configured in either push or pull mode, but they share the same interface. However, only tasks with {@link TaskOptions.Method#PULL} maybe added to pull queues. The tasks in push queues must be added with one of the other available methods.
Pull mode queues do not automatically deliver tasks to the application. The application is required to call {@link #leaseTasks(long,TimeUnit,long) leaseTasks} to acquire a lease onthe task and process them explicitly. Attempting to call {@link #leaseTasks(long,TimeUnit,long) leaseTasks} on a push queue causesa {@link InvalidQueueModeException} to be thrown. When the task processinghas finished processing a task that is leased, it should call {@link #deleteTask(String)}. If deleteTask is not called before the lease expires, the task will again be available for lease.
Queue mode can be switched between push and pull. When switching from push to pull, tasks will stay in the task queue and are available for lease, but url and headers information will be ignored when returning the tasks. When switching from pull to push, existing tasks will remain in the queue but will fail on auto-execution because they lack a url. If the queue mode is once again changed to pull, these tasks will eventually be available for lease.
Queue represents an identity of a repository of messages used in the JMS Point-To-Point messaging domain.
@see javax.jms.Queue javax.jms.Queue
| Throws exception | Special value | |
| Insert | {@link #add add(e)} | {@link #offer offer(e)} |
| Remove | {@link #remove remove()} | {@link #poll poll()} |
| Examine | {@link #element element()} | {@link #peek peek()} |
Queues typically, but do not necessarily, order elements in a FIFO (first-in-first-out) manner. Among the exceptions are priority queues, which order elements according to a supplied comparator, or the elements' natural ordering, and LIFO queues (or stacks) which order the elements LIFO (last-in-first-out). Whatever the ordering used, the head of the queue is that element which would be removed by a call to {@link #remove() } or{@link #poll()}. In a FIFO queue, all new elements are inserted at the tail of the queue. Other kinds of queues may use different placement rules. Every Queue implementation must specify its ordering properties.
The {@link #offer offer} method inserts an element if possible,otherwise returning false. This differs from the {@link java.util.Collection#add Collection.add} method, which can fail toadd an element only by throwing an unchecked exception. The offer method is designed for use when failure is a normal, rather than exceptional occurrence, for example, in fixed-capacity (or "bounded") queues.
The {@link #remove()} and {@link #poll()} methods remove andreturn the head of the queue. Exactly which element is removed from the queue is a function of the queue's ordering policy, which differs from implementation to implementation. The remove() and poll() methods differ only in their behavior when the queue is empty: the remove() method throws an exception, while the poll() method returns null.
The {@link #element()} and {@link #peek()} methods return, but donot remove, the head of the queue.
The Queue interface does not define the blocking queue methods, which are common in concurrent programming. These methods, which wait for elements to appear or for space to become available, are defined in the {@link edu.emory.mathcs.backport.java.util.concurrent.BlockingQueue} interface, whichextends this interface.
Queue implementations generally do not allow insertion of null elements, although some implementations, such as {@link LinkedList}, do not prohibit insertion of null. Even in the implementations that permit it, null should not be inserted into a Queue, as null is also used as a special return value by the poll method to indicate that the queue contains no elements.
Queue implementations generally do not define element-based versions of methods equals and hashCode but instead inherit the identity based versions from class Object, because element-based equality is not always well-defined for queues with the same elements but different ordering properties.
This interface is a member of the Java Collections Framework. @see java.util.Collection @see LinkedList @see PriorityQueue @see edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingQueue @see edu.emory.mathcs.backport.java.util.concurrent.BlockingQueue @see edu.emory.mathcs.backport.java.util.concurrent.ArrayBlockingQueue @see edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingQueue @see edu.emory.mathcs.backport.java.util.concurrent.PriorityBlockingQueue @since 1.5 @author Doug Lea
Queue class implements a First-In-First-Out (FIFO) list of objects. A queue is for the exclusive use of one single consumer, whereas many producers may access it. It is ready for use after instantiation. A producer may wait for the queue to be empty by calling the stop() method. This method returns when the queue is actually empty, and prohibits any further call to the push method. To be able to use the queue again, it must be re-started through the start() method.
This class implements the core scheduling logic. {@link Task} represents the executabletask that are placed in the queue. While in the queue, it's wrapped into {@link Item}so that we can keep track of additional data used for deciding what to exeucte when.
Items in queue goes through several stages, as depicted below:
(enter) --> waitingList --+--> blockedProjects | ^ | | | v +--> buildables ---> pending ---> (executed)
In addition, at any stage, an item can be removed from the queue (for example, when the user cancels a job in the queue.) See the corresponding field for their exact meanings. @author Kohsuke Kawaguchi
| Throws exception | Returns special value | |
| Insert | {@link #add add(e)} | {@link #offer offer(e)} |
| Remove | {@link #remove remove()} | {@link #poll poll()} |
| Examine | {@link #element element()} | {@link #peek peek()} |
Queues typically, but do not necessarily, order elements in a FIFO (first-in-first-out) manner. Among the exceptions are priority queues, which order elements according to a supplied comparator, or the elements' natural ordering, and LIFO queues (or stacks) which order the elements LIFO (last-in-first-out). Whatever the ordering used, the head of the queue is that element which would be removed by a call to {@link #remove() } or{@link #poll()}. In a FIFO queue, all new elements are inserted at the tail of the queue. Other kinds of queues may use different placement rules. Every Queue implementation must specify its ordering properties.
The {@link #offer offer} method inserts an element if possible,otherwise returning false. This differs from the {@link java.util.Collection#add Collection.add} method, which can fail toadd an element only by throwing an unchecked exception. The offer method is designed for use when failure is a normal, rather than exceptional occurrence, for example, in fixed-capacity (or "bounded") queues.
The {@link #remove()} and {@link #poll()} methods remove andreturn the head of the queue. Exactly which element is removed from the queue is a function of the queue's ordering policy, which differs from implementation to implementation. The remove() and poll() methods differ only in their behavior when the queue is empty: the remove() method throws an exception, while the poll() method returns null.
The {@link #element()} and {@link #peek()} methods return, but donot remove, the head of the queue.
The Queue interface does not define the blocking queue methods, which are common in concurrent programming. These methods, which wait for elements to appear or for space to become available, are defined in the {@link java.util.concurrent.BlockingQueue} interface, whichextends this interface.
Queue implementations generally do not allow insertion of null elements, although some implementations, such as {@link LinkedList}, do not prohibit insertion of null. Even in the implementations that permit it, null should not be inserted into a Queue, as null is also used as a special return value by the poll method to indicate that the queue contains no elements.
Queue implementations generally do not define element-based versions of methods equals and hashCode but instead inherit the identity based versions from class Object, because element-based equality is not always well-defined for queues with the same elements but different ordering properties.
This interface is a member of the Java Collections Framework. @see java.util.Collection @see LinkedList @see PriorityQueue @see java.util.concurrent.LinkedBlockingQueue @see java.util.concurrent.BlockingQueue @see java.util.concurrent.ArrayBlockingQueue @see java.util.concurrent.LinkedBlockingQueue @see java.util.concurrent.PriorityBlockingQueue @since 1.5 @author Doug Lea @param < E> the type of elements held in this collection
Name: Queue
Description:
Date: 15/nov/2009 Time: 23.08.16
@author Bertoli Marco [marco.bertoli@neptuny.com] @version 3.0The interface design is heavily influenced by Matt Welsh's SandStorm server, his demonstration of the SEDA architecture. We have deviated where we felt the design differences where better.
@author Avalon Development TeamQueue class is a very simple queue assuming that there is at least one consumer and potentially multiple producers. This class poses no restrictions on the size of the queue.
@author Felix Meschberger
Queue TODO
javax.jms.Queue interface and provides Joram specific administration and monitoring methods. This is a proxy object a client uses to specify the destination of messages it is sending and the source of messages it receives.
Queue class implements the MOM queue behavior, basically storing messages and delivering them upon clients requests.
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |