ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/jsr166x/BlockingDeque.java

Comparing jsr166/src/jsr166x/BlockingDeque.java (file contents):
Revision 1.4 by jsr166, Tue Mar 15 19:47:02 2011 UTC vs.
Revision 1.9 by jsr166, Fri Jul 15 18:49:12 2016 UTC

#	Line 5 | Line 5
5		*/
6
7		package jsr166x;     // XXX This belongs in java.util!!! XXX
8	+
9		import java.util.concurrent.*;  // XXX This import goes away        XXX
10		import java.util.*;
11
#	Line 43 | Line 44 | import java.util.*;
44		*  </tr>
45		* </table>
46		*
47	<	* <p>Like any {@link BlockingQueue}, a <tt>BlockingDeque</tt> is
47	>	* <p>Like any {@link BlockingQueue}, a {@code BlockingDeque} is
48		* thread safe and may (or may not) be capacity-constrained.  A
49	<	* <tt>BlockingDeque</tt> implementation may be used directly as a
50	<	* FIFO <tt>BlockingQueue</tt>. The blocking methods inherited from
51	<	* the <tt>BlockingQueue</tt> interface are precisely equivalent to
52	<	* <tt>BlockingDeque</tt> methods as indicated in the following table:<p>
49	>	* {@code BlockingDeque} implementation may be used directly as a
50	>	* FIFO {@code BlockingQueue}. The blocking methods inherited from
51	>	* the {@code BlockingQueue} interface are precisely equivalent to
52	>	* {@code BlockingDeque} methods as indicated in the following table:<p>
53		*
54		* <table BORDER CELLPADDING=3 CELLSPACING=1>
55		*  <tr>
56	<	*    <td ALIGN=CENTER> <b><tt>BlockingQueue</tt> Method</b></td>
57	<	*    <td ALIGN=CENTER> <b>Equivalent <tt>BlockingDeque</tt> Method</b></td>
56	>	*    <td ALIGN=CENTER> <b>{@code BlockingQueue} Method</b></td>
57	>	*    <td ALIGN=CENTER> <b>Equivalent {@code BlockingDeque} Method</b></td>
58		*  </tr>
59		*  <tr>
60		*   <tr>
#	Line 74 | Line 75 | import java.util.*;
75		*   </tr>
76		* </table>
77		*
77	–	*
78		* <p>This interface is a member of the
79		* <a href="{@docRoot}/../guide/collections/index.html">
80		* Java Collections Framework</a>.
#	Line 89 | Line 89 | public interface BlockingDeque<E> extend
89		* Adds the specified element as the first element of this deque,
90		* waiting if necessary for space to become available.
91		* @param o the element to add
92	<	* @throws InterruptedException if interrupted while waiting.
93	<	* @throws NullPointerException if the specified element is <tt>null</tt>.
92	>	* @throws InterruptedException if interrupted while waiting
93	>	* @throws NullPointerException if the specified element is {@code null}
94		*/
95		void putFirst(E o) throws InterruptedException;
96
#	Line 98 | Line 98 | public interface BlockingDeque<E> extend
98		* Adds the specified element as the last element of this deque,
99		* waiting if necessary for space to become available.
100		* @param o the element to add
101	<	* @throws InterruptedException if interrupted while waiting.
102	<	* @throws NullPointerException if the specified element is <tt>null</tt>.
101	>	* @throws InterruptedException if interrupted while waiting
102	>	* @throws NullPointerException if the specified element is {@code null}
103		*/
104		void putLast(E o) throws InterruptedException;
105
#	Line 107 | Line 107 | public interface BlockingDeque<E> extend
107		* Retrieves and removes the first element of this deque, waiting
108		* if no elements are present on this deque.
109		* @return the head of this deque
110	<	* @throws InterruptedException if interrupted while waiting.
110	>	* @throws InterruptedException if interrupted while waiting
111		*/
112		E takeFirst() throws InterruptedException;
113
#	Line 115 | Line 115 | public interface BlockingDeque<E> extend
115		* Retrieves and removes the last element of this deque, waiting
116		* if no elements are present on this deque.
117		* @return the head of this deque
118	<	* @throws InterruptedException if interrupted while waiting.
118	>	* @throws InterruptedException if interrupted while waiting
119		*/
120		E takeLast() throws InterruptedException;
121
#	Line 125 | Line 125 | public interface BlockingDeque<E> extend
125		* become available.
126		* @param o the element to add
127		* @param timeout how long to wait before giving up, in units of
128	<	* <tt>unit</tt>
129	<	* @param unit a <tt>TimeUnit</tt> determining how to interpret the
130	<	* <tt>timeout</tt> parameter
131	<	* @return <tt>true</tt> if successful, or <tt>false</tt> if
132	<	* the specified waiting time elapses before space is available.
133	<	* @throws InterruptedException if interrupted while waiting.
134	<	* @throws NullPointerException if the specified element is <tt>null</tt>.
128	>	* {@code unit}
129	>	* @param unit a {@code TimeUnit} determining how to interpret the
130	>	* {@code timeout} parameter
131	>	* @return {@code true} if successful, or {@code false} if
132	>	* the specified waiting time elapses before space is available
133	>	* @throws InterruptedException if interrupted while waiting
134	>	* @throws NullPointerException if the specified element is {@code null}
135		*/
136		boolean offerFirst(E o, long timeout, TimeUnit unit)
137		throws InterruptedException;
#	Line 142 | Line 142 | public interface BlockingDeque<E> extend
142		* become available.
143		* @param o the element to add
144		* @param timeout how long to wait before giving up, in units of
145	<	* <tt>unit</tt>
146	<	* @param unit a <tt>TimeUnit</tt> determining how to interpret the
147	<	* <tt>timeout</tt> parameter
148	<	* @return <tt>true</tt> if successful, or <tt>false</tt> if
149	<	* the specified waiting time elapses before space is available.
150	<	* @throws InterruptedException if interrupted while waiting.
151	<	* @throws NullPointerException if the specified element is <tt>null</tt>.
145	>	* {@code unit}
146	>	* @param unit a {@code TimeUnit} determining how to interpret the
147	>	* {@code timeout} parameter
148	>	* @return {@code true} if successful, or {@code false} if
149	>	* the specified waiting time elapses before space is available
150	>	* @throws InterruptedException if interrupted while waiting
151	>	* @throws NullPointerException if the specified element is {@code null}
152		*/
153		boolean offerLast(E o, long timeout, TimeUnit unit)
154		throws InterruptedException;
#	Line 159 | Line 159 | public interface BlockingDeque<E> extend
159		* if necessary up to the specified wait time if no elements are
160		* present on this deque.
161		* @param timeout how long to wait before giving up, in units of
162	<	* <tt>unit</tt>
163	<	* @param unit a <tt>TimeUnit</tt> determining how to interpret the
164	<	* <tt>timeout</tt> parameter
165	<	* @return the head of this deque, or <tt>null</tt> if the
166	<	* specified waiting time elapses before an element is present.
167	<	* @throws InterruptedException if interrupted while waiting.
162	>	* {@code unit}
163	>	* @param unit a {@code TimeUnit} determining how to interpret the
164	>	* {@code timeout} parameter
165	>	* @return the head of this deque, or {@code null} if the
166	>	* specified waiting time elapses before an element is present
167	>	* @throws InterruptedException if interrupted while waiting
168		*/
169		E pollFirst(long timeout, TimeUnit unit)
170		throws InterruptedException;
#	Line 174 | Line 174 | public interface BlockingDeque<E> extend
174		* if necessary up to the specified wait time if no elements are
175		* present on this deque.
176		* @param timeout how long to wait before giving up, in units of
177	<	* <tt>unit</tt>
178	<	* @param unit a <tt>TimeUnit</tt> determining how to interpret the
179	<	* <tt>timeout</tt> parameter
180	<	* @return the head of this deque, or <tt>null</tt> if the
181	<	* specified waiting time elapses before an element is present.
182	<	* @throws InterruptedException if interrupted while waiting.
177	>	* {@code unit}
178	>	* @param unit a {@code TimeUnit} determining how to interpret the
179	>	* {@code timeout} parameter
180	>	* @return the head of this deque, or {@code null} if the
181	>	* specified waiting time elapses before an element is present
182	>	* @throws InterruptedException if interrupted while waiting
183		*/
184		E pollLast(long timeout, TimeUnit unit)
185		throws InterruptedException;
#	Line 187 | Line 187 | public interface BlockingDeque<E> extend
187		/**
188		* Adds the specified element as the last element of this deque,
189		* waiting if necessary for space to become available.  This
190	<	* method is equivalent to putLast
190	>	* method is equivalent to putLast.
191		* @param o the element to add
192	<	* @throws InterruptedException if interrupted while waiting.
193	<	* @throws NullPointerException if the specified element is <tt>null</tt>.
192	>	* @throws InterruptedException if interrupted while waiting
193	>	* @throws NullPointerException if the specified element is {@code null}
194		*/
195		void put(E o) throws InterruptedException;
196
#	Line 198 | Line 198 | public interface BlockingDeque<E> extend
198		* Inserts the specified element as the lest element of this
199		* deque, if possible.  When using deques that may impose
200		* insertion restrictions (for example capacity bounds), method
201	<	* <tt>offer</tt> is generally preferable to method {@link
201	>	* {@code offer} is generally preferable to method {@link
202		* Collection#add}, which can fail to insert an element only by
203		* throwing an exception.  This method is equivalent to
204	<	* offerLast
204	>	* offerLast.
205		*
206	<	* @param o the element to add.
207	<	* @return <tt>true</tt> if it was possible to add the element to
208	<	*         this deque, else <tt>false</tt>
209	<	* @throws NullPointerException if the specified element is <tt>null</tt>
206	>	* @param o the element to add
207	>	* @return {@code true} if it was possible to add the element to
208	>	*         this deque, else {@code false}
209	>	* @throws NullPointerException if the specified element is {@code null}
210		*/
211		boolean offer(E o, long timeout, TimeUnit unit)
212		throws InterruptedException;
#	Line 214 | Line 214 | public interface BlockingDeque<E> extend
214		/**
215		* Retrieves and removes the first element of this deque, waiting
216		* if no elements are present on this deque.
217	<	* This method is equivalent to takeFirst
217	>	* This method is equivalent to takeFirst.
218		* @return the head of this deque
219	<	* @throws InterruptedException if interrupted while waiting.
219	>	* @throws InterruptedException if interrupted while waiting
220		*/
221		E take() throws InterruptedException;
222
#	Line 224 | Line 224 | public interface BlockingDeque<E> extend
224		* Retrieves and removes the first element of this deque, waiting
225		* if necessary up to the specified wait time if no elements are
226		* present on this deque.  This method is equivalent to
227	<	* pollFirst
227	>	* pollFirst.
228		* @param timeout how long to wait before giving up, in units of
229	<	* <tt>unit</tt>
230	<	* @param unit a <tt>TimeUnit</tt> determining how to interpret the
231	<	* <tt>timeout</tt> parameter
232	<	* @return the head of this deque, or <tt>null</tt> if the
233	<	* specified waiting time elapses before an element is present.
234	<	* @throws InterruptedException if interrupted while waiting.
229	>	* {@code unit}
230	>	* @param unit a {@code TimeUnit} determining how to interpret the
231	>	* {@code timeout} parameter
232	>	* @return the head of this deque, or {@code null} if the
233	>	* specified waiting time elapses before an element is present
234	>	* @throws InterruptedException if interrupted while waiting
235		*/
236		E poll(long timeout, TimeUnit unit)
237		throws InterruptedException;

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines